Pular para o conteúdo principal
Version: v4.5.0

Teste de Stacks

Nesta Página

Esta seção tem o objetivo de orientar no desenvolvimento e execução de testes para cada um dos Plugins e Templates que você desenvolver.

Sobre teste de Stacks​

Para você criar Stacks, a StackSpot disponibiliza um modelo simples e fácil para que você possa testar as Stacks, Templates e Plugins.

Quando você finalizar o desenvolvimento de uma Stack, você deve criar e executar casos de teste para garantir que cada Template e Plugin funcione conforme o esperado.

Estrutura dos testes da Stack​

Você precisa executar os testes dentro da pasta da Stack desejada, é onde todos os casos de testes para os Templates e Plugins devem estar para serem executados.

Assim como a estrutura de Templates e Plugins, para criar testes, é necessário seguir um padrão. Você pode criar quantos casos de testes desejar, seguindo os passos descritos abaixo:

  1. Dentro do Plugin e Template criar a pasta "/tests";
  2. Esta pasta deve ter o nome do caso de teste que você deseja para o seu Plugin ou Template.

Confira o exemplo:

./my-stack-java
. 
.
.
├── java-kafka-plugin
│   ├── template.yaml
│   ├── templates
│   └── tests
│       └── kafka-plugin-test-case-1
│           ├── expected
│           └── inputs.yaml
└── stack.yaml

Com um caso de teste criado na pasta /tests , alguns outros elementos devem compor a estrutura do teste. Confira abaixo os itens obrigatórios para um caso de teste:

  • Pasta expected:
    A pasta expected deve conter todos os arquivos que são esperados quando o Template ou Plugin forem utilizados para criar uma aplicação.

  • Pasta target:
    A pasta target é de uso exclusivo para o caso de teste de Plugins, e representa uma aplicação onde o Plugin deve ser aplicado. Essa pasta deve conter o conteúdo do app com o estado anterior a aplicação do Plugin que deseja realizar o teste.

  • Arquivo inputs.yaml:
    O arquivo inputs.yaml de um caso de teste de um Plugin ou Template, define todos os inputs esperados de cada um.

info

A pasta target é exclusiva para casos de teste de Plugins.

O exemplo abaixo é de uma Stack com casos de testes para o Template e Plugin. Esse exemplo representa a estrutura que a sua Stack deve ter após criar um caso de teste:

./my-stack-folder
.
├── some-plugin-folder
│   ├── plugin.yaml
│   ├── templates
│   └── tests
│       └── plugin-test-case
│           ├── expected
│           ├── inputs.yaml
│           └── target
├── some-template-folder
│   ├── template.yaml
│   ├── templates
│   └── tests
│       └── template-test-case
│           ├── expected
│           └── inputs.yaml
└── stack.yaml

Criar e executar testes​

O teste de Stacks fornece um modelo simples para padronizar e executar testes nas estruturas dos Templates e Plugins. Os testes não cobrem o conteúdo da Stack como Templates e Plugins de componentes IaC, códigos fonte, arquivos de configuração de ambientes, entre outros.

  • Para executar os testes, utilize o comando stk-legacy test.
  • Para validar os dados da sua Stack, execute o comando stk-legacy validate, o comando de teste não cobre as validações do comando stk-legacy validate.

Antes de você começar​

  1. Crie a pasta tests na raiz da pasta do seu Plugin e/ou Template.
  2. Dentro da pasta tests, crie uma pasta com o nome de cada caso de teste que você deseja criar.

Exemplo:

.plugin-or-template-folder/tests
.
├── plugin-abc-case-1
├── plugin-abc-case-2
├── template-abc-case-1
└── template-abc-case-2
  1. Para cada caso de teste, crie dentro de cada um deles, as pastas:
    • Nos casos de teste para Templates, crie a pasta expected.
    • Nos casos de teste para Plugins, crie as pastas expected e target.
  2. Crie o arquivo inputs.yaml.

Criar o arquivo inputs.yaml​

Você deve criar o arquivo inputs.yaml na raiz da pasta do caso de teste. Ele deve conter todos os inputs do Plugin ou Template que serão testados.

Para preencher o arquivo você deve inserir o valor do campo name: (nome) dos inputs do Template ou Plugin como atributo do inputs.yaml, e como valor, um valor válido conforme o tipo do input. Confira a sintaxe desses campos no exemplo abaixo:

inputs.yaml
input_text: some text value
input_bool: true
input_select: some-valid-value
input_multi_select:
 - some-valid-value-1
 - some-valid-value-2

Dessa forma, considere que seu Template e Plugin tenham os seguintes inputs:

Exemplo de inputs para o plugin.yaml e template.yaml
inputs:
 - label: "Type your name: "
   name: "input_text"
   type: text
   default: "jose"
 - label: "42 is the answer ?"
   name: "input_bool"
   type: bool 
 - label: "what is your favorite number ?"
   name: "input_int"
   type: int
   default: 42 
 - label: "Choose one or more days: "
   type: multiselect
   name: "input_days"
      default:
     - "Monday"
     - "Tuesday"
   items:
     - "Monday"
     - "Tuesday"
     - "Wednesday"
     - "Thursday"
     - "Friday"
     - "Saturday"
     - "Sunday"

O seu arquivo inputs.yaml para esses inputs deve ser:

inputs.yaml
input_text: some text value
input_bool: false
input_int: 123
input_days:
 - "Monday"
 - "Tuesday"
 - "Wednesday"
 - "Thursday"
 - "Friday"
 - "Saturday"
 - "Sunday"

Teste para Templates​

Para testar seus Templates, você deve:

  1. Criar e preencher o arquivo inputs.yaml.
  2. Dentro da pasta expected, colocar todos os arquivos de uma aplicação, gerada utilizando o Template que você quer testar.

Para executar o caso de teste, execute o comando stk-legacy test e as opções dele. Confira os exemplos abaixo:

stk-legacy test template

Teste para Plugins​

No caso de teste para Plugins, você deve:

  1. Criar e preencher o arquivo inputs.yaml.
  2. Dentro da pasta expected, colocar todos os arquivos de uma aplicação, que foi gerada utilizando um Template da sua Stack e o Plugin que você quer testar já aplicado.
  3. Dentro da pasta target, você deve colocar todos os arquivos de uma aplicação, gerada utilizando um Template ou Stackfile da sua Stack.

Para executar o caso de teste, execute o comando stk test e a opções dele. Confira os exemplos abaixo:

stk-legacy test plugin

Executar todos os testes da Stack​

Para executar todos os testes de Plugins e Templates de uma Stack, execute o comando abaixo:

stk-legacy test stack

Esta página foi útil?