Configure a máquina de estados do IDT - AWS IoT Greengrass
Formato da máquina de estadosEstados válidos e definições de estadoContexto da máquina de estadosErros de execuçãoExemplo de máquinas de estados

AWS IoT Greengrass Version 1 entrou na fase de vida útil prolongada em 30 de junho de 2023. Para obter mais informações, consulte política de manutenção do AWS IoT Greengrass V1. Após essa data, AWS IoT Greengrass V1 não lançaremos atualizações que forneçam recursos, aprimoramentos, correções de erros ou patches de segurança. Os dispositivos que funcionam AWS IoT Greengrass V1 não serão interrompidos e continuarão operando e se conectando à nuvem. É altamente recomendável que você migre para AWS IoT Greengrass Version 2, o que adiciona novos recursos significativos e suporte para plataformas adicionais.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Configure a máquina de estados do IDT

Uma máquina de estados é uma estrutura que controla o fluxo de execução do pacote de testes. Ela determina o estado inicial de um pacote de testes, gerencia as transições de estado com base nas regras definidas pelo usuário e continua avançando por esses estados até atingir o estado final.

Se seu pacote de testes não incluir uma máquina de estados definida pelo usuário, o IDT gerará uma máquina de estados para você. A máquina padrão de estados executa as seguintes funções:

  • Fornece aos executores de teste a capacidade de selecionar e executar grupos de testes específicos, em vez de todo o pacote de testes.

  • Se grupos de testes específicos não forem selecionados, executará cada grupo de testes no pacote de testes em uma ordem aleatória.

  • Gera relatórios e imprime um resumo do console que mostra os resultados do teste para cada grupo de testes e caso de teste.

A máquina de estados de um pacote de testes do IDT deve atender aos seguintes critérios:

  • Cada estado corresponde a uma ação a ser executada pelo IDT, como executar um grupo de testes ou produzir um arquivo de relatório.

  • A transição para um estado executa a ação associada ao estado.

  • Cada estado define a regra de transição para o próximo estado.

  • O estado final deve ser Succeed ou Fail.

Formato da máquina de estados

Você pode usar o modelo a seguir para configurar seu próprio arquivo <custom-test-suite-folder>/suite/state_machine.json: 

{
  "Comment": "<description>",
  "StartAt": "<state-name>",
  "States": {
    "<state-name>": {
      "Type": "<state-type>",
      // Additional state configuration
    }
    
    // Required states
    "Succeed": {
      "Type": "Succeed"
    },
    "Fail": {
      "Type": "Fail"
    }
  }
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Comment

Uma descrição da máquina de estados.

StartAt

O nome do estado em que o IDT começa a executar o pacote de testes. O valor de StartAt deve ser definido como um dos estados listados no objeto States.

States

Um objeto que mapeia nomes de estados definidos pelo usuário para estados válidos do IDT. Cada estado do objeto state-name contém a definição de um estado válido mapeado para o state-name.

O objeto States deve incluir os estados Succeed e Fail. Para obter informações sobre estados válidos, consulte Estados válidos e definições de estado.

Estados válidos e definições de estado

Esta seção descreve as definições de estado de todos os estados válidos que podem ser usados na máquina de estados do IDT. Alguns dos estados a seguir oferecem suporte a configurações no nível do caso de teste. No entanto, recomendamos que você configure as regras de transição de estado no nível do grupo de teste em vez de no nível do caso de teste, a menos que seja absolutamente necessário.

RunTask

O estado RunTask executa casos de teste de um grupo de teste definido no pacote de testes.

{
    "Type": "RunTask",
    "Next": "<state-name>",
    "TestGroup": "<group-id>",
    "TestCases": [
        "<test-id>"
    ],
    "ResultVar": "<result-name>"
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

TestGroup

Opcional. O ID do grupo de testes a ser executado. Se esse valor não for especificado, o IDT executará o grupo de teste selecionado pelo executor do teste.

TestCases

Opcional. Uma matriz de IDs de casos de teste do grupo especificado em TestGroup. Com base nos valores de TestGroup e TestCases, o IDT determina o comportamento da execução do teste da seguinte forma:

  • Quando TestGroup e TestCases são especificados, o IDT executa os casos de teste especificados do grupo de teste.

  • Quando TestCases são especificados, mas TestGroup não é especificado, o IDT executa os casos de teste especificados.

  • Quando TestGroup é especificado, mas TestCases não é especificado, o IDT executa todos os casos de teste dentro do grupo de testes especificado.

  • Quando nem TestGroup nem TestCases é especificado, o IDT executa todos os casos de teste do grupo de testes que o executor de testes seleciona na CLI do IDT. Para habilitar a seleção de grupos para executores de teste, você deve incluir os estados RunTask e Choice em seu arquivo statemachine.json. Para ver um exemplo de como isso funciona, consulte Exemplo de máquina de estados: executar grupos de testes selecionados pelo usuário.

    Para obter mais informações sobre como habilitar os comandos da CLI do IDT para executores de teste, consulte Habilitar os comandos da CLI do IDT.

ResultVar

O nome da variável de contexto a ser definida com os resultados da execução do teste. Não especifique esse valor se você não especificou um valor paraTestGroup. O IDT define o valor da variável que você define em ResultVar para true ou false com base no seguinte:

  • Se o nome da variável estiver no formato text_text_passed, o valor será definido como se todos os testes do primeiro grupo de teste tivessem sido aprovados ou ignorados.

  • Em todos os outros casos, o valor é definido como se todos os testes em todos os grupos de testes tivessem sido aprovados ou ignorados.

Normalmente, você usará o estado RunTask para especificar um ID de grupo de testes sem especificar IDs de caso de teste individuais, para que o IDT execute todos os casos de teste no grupo de testes especificado. Todos os casos de teste executados por esse estado são executados em paralelo, em uma ordem aleatória. No entanto, se todos os casos de teste exigirem a execução de um dispositivo e apenas um único dispositivo estiver disponível, os casos de teste serão executados sequencialmente.

Como tratar erros

Se algum dos grupos de testes ou IDs de casos de teste especificados não for válido, esse estado emitirá o erro de execução RunTaskError. Se o estado encontrar um erro de execução, ele também definirá a variável hasExecutionError no contexto da máquina de estados como true.

Choice

O estado Choice permite que você defina dinamicamente o próximo estado para o qual fazer a transição com base nas condições definidas pelo usuário.

{
    "Type": "Choice",
    "Default": "<state-name>", 
    "FallthroughOnError": true | false,
    "Choices": [
        {
            "Expression": "<expression>",
            "Next": "<state-name>"
        }
    ]
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Default

O estado padrão para o qual fazer a transição se nenhuma das expressões definidas em Choices puder ser avaliada como true.

FallthroughOnError

Opcional. Especifica o comportamento quando o estado encontra um erro na avaliação de expressões. Defina como true se você quiser pular uma expressão se a avaliação resultar em um erro. Se nenhuma expressão tiver correspondência, a máquina de estados fará a transição para o estado Default. Se o valor FallthroughOnError não for especificado, ele assume false como padrão.

Choices

Uma matriz de expressões e estados para determinar para qual estado fazer a transição depois de executar as ações no estado atual.

Choices.Expression

Uma string de expressões que avalia para um valor booliano. Se a expressão for avaliada como true, a máquina de estados fará a transição para o estado definido em Choices.Next. As strings de expressões recuperam valores do contexto da máquina de estados e, em seguida, executam operações neles para chegar a um valor booliano. Para obter informações sobre como acessar o contexto da máquina de estado, consulte Contexto da máquina de estados.

Choices.Next

O nome do estado para o qual fazer a transição se a expressão definida em Choices.Expression for avaliada como true.

Como tratar erros

O estado Choice pode exigir tratamento de erros nos seguintes casos:

  • Algumas variáveis nas expressões de selecione não existem no contexto da máquina de estado.

  • O resultado de uma expressão não é um valor booliano.

  • O resultado de uma pesquisa JSON não é uma string, um número ou um booliano.

Você não pode usar um bloco Catch para tratar erros nesse estado. Se você quiser parar de executar a máquina de estados quando ela encontrar um erro, defina FallthroughOnError como false. No entanto, recomendamos que você configure FallthroughOnError para true e, dependendo do caso de uso, execute um dos seguintes procedimentos:

  • Se for esperado que uma variável que você está acessando não exista em alguns casos, use o valor de Default e blocos Choices adicionais para especificar o próximo estado.

  • Se uma variável que você está acessando sempre existir, defina o estado Default como Fail.

Parallel

O estado Parallel permite que você defina e execute novas máquinas de estados paralelamente umas às outras.

{
    "Type": "Parallel",
    "Next": "<state-name>",
    "Branches": [
        <state-machine-definition>
    ]
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

Branches

Uma matriz de definições de máquina de estados a serem executadas. Cada definição de máquina de estados deve conter seus próprios estados StartAt, Succeed e Fail. As definições da máquina de estados nessa matriz não podem referenciar estados fora de sua própria definição.

nota

Como cada máquina de estados de ramificação compartilha o mesmo contexto de máquina de estados, definir variáveis em uma ramificação e depois ler essas variáveis em outra ramificação pode resultar em um comportamento inesperado.

O estado Parallel passa para o próximo estado somente depois de executar todas as máquinas de estados da ramificação. Cada estado que requer um dispositivo aguardará para ser executado até que o dispositivo esteja disponível. Se vários dispositivos estiverem disponíveis, esse estado executará casos de teste de vários grupos em paralelo. Se não houver dispositivos suficientes disponíveis, os casos de teste serão executados sequencialmente. Como os casos de teste são executados em uma ordem aleatória quando executados em paralelo, dispositivos diferentes podem ser usados para executar testes do mesmo grupo de testes.

Como tratar erros

Certifique-se de que tanto a máquina de estado da ramificação quanto a máquina de estado principal façam a transição para o estado Fail para tratar erros de execução.

Como as máquinas de estado de ramificação não transmitem erros de execução para a máquina de estado principal, você não pode usar um bloco Catch para lidar com erros de execução em máquinas de estados de ramificação. Em vez disso, use o valor hasExecutionErrors no contexto da máquina de estados compartilhada. Para obter um exemplo de como isso funciona, consulte Exemplo de máquina de estado: execute dois grupos de teste em paralelo.

AddProductFeatures

O estado AddProductFeatures permite adicionar atributos do produto ao arquivo awsiotdevicetester_report.xml gerado pelo IDT.

Um atributo do produto é uma informação definida pelo usuário sobre critérios específicos que um dispositivo pode atender. Por exemplo, o atributo MQTT do produto pode indicar que o dispositivo publica mensagens MQTT corretamente. No relatório, os atributos do produto são definidas como supported, not-supported ou um valor personalizado, com base na aprovação dos testes especificados.

nota

O estado AddProductFeatures não gera relatórios sozinho. Esse estado deve fazer a transição para o estado Report para gerar relatórios.

{
    "Type": "Parallel",
    "Next": "<state-name>",
    "Features": [
        {
            "Feature": "<feature-name>", 
            "Groups": [
                "<group-id>"
            ],
            "OneOfGroups": [
                "<group-id>"
            ],
            "TestCases": [
                "<test-id>"
            ],
            "IsRequired": true | false,
            "ExecutionMethods": [
                "<execution-method>"
            ]
        }
    ]
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

Features

Uma matriz de atributos do produto para mostrar no arquivo awsiotdevicetester_report.xml.

Feature

O nome do atributo

FeatureValue

Opcional. O valor personalizado a ser usado no relatório em vez de supported. Se esse valor não for especificado, com base nos resultados do teste, o valor do atributo será definido como supported ou not-supported.

Se você usar um valor personalizado para FeatureValue, você poderá testar o mesmo atributo com condições diferentes, e o IDT concatena os valores do atributo para as condições compatíveis. Por exemplo, o trecho a seguir mostra o atributo MyFeature com dois valores de atributo separados:

...
{
    "Feature": "MyFeature",
    "FeatureValue": "first-feature-supported",
    "Groups": ["first-feature-group"]
},
{
    "Feature": "MyFeature",
    "FeatureValue": "second-feature-supported",
    "Groups": ["second-feature-group"]
},
...

Se os dois grupos de teste forem aprovados, o valor do atributo será definido como first-feature-supported, second-feature-supported.

Groups

Opcional. Uma matriz de IDs de grupos de testes. Todos os testes dentro de cada grupo de testes especificado devem ser aprovados para que o atributo receba suporte.

OneOfGroups

Opcional. Uma matriz de IDs de grupos de testes. Todos os testes em pelo menos um dos grupos de testes especificados devem ser aprovados para que o atributo receba suporte.

TestCases

Opcional. Uma matriz de IDs de casos de teste. Se você especificar esse valor, o seguinte se aplica:

  • Todos os casos de teste especificados devem ser aprovados para que o atributo receba suporte.

  • Groups deve conter somente um ID do grupo de testes.

  • OneOfGroups não deve ser especificado.

IsRequired

Opcional. Defina como false para marcar esse atributo como um atributo opcional no relatório. O valor padrão é true.

ExecutionMethods

Opcional. Uma matriz de métodos de execução que correspondem ao valor protocol especificado no arquivo device.json. Se esse valor for especificado, os executores de teste deverão especificar um valor protocol que corresponda a um dos valores dessa matriz para incluir o atributo no relatório. Se esse valor não for especificado, o atributo sempre será incluído no relatório.

Para usar o estado AddProductFeatures, você deve definir o valor de ResultVar no estado RunTask como um dos seguintes valores:

  • Se você especificou IDs de casos de teste individuais, defina ResultVar como group-id_test-id_passed.

  • Se você não especificou IDs de casos de teste individuais, defina ResultVar como group-id_passed.

O estado AddProductFeatures verifica os resultados dos testes da seguinte maneira:

  • Se você não especificou nenhum ID de caso de teste, o resultado de cada grupo de testes será determinado a partir do valor da variável group-id_passed no contexto da máquina de estados.

  • Se você especificou IDs de casos de teste, o resultado de cada um dos testes será determinado a partir do valor da variável group-id_test-id_passed no contexto da máquina de estados.

Como tratar erros

Se um ID de grupo fornecida nesse estado não for uma ID de grupo válida, esse estado resultará no erro de execução AddProductFeaturesError. Se o estado encontrar um erro de execução, ele também definirá a variável hasExecutionErrors no contexto da máquina de estados como true.

Relatório

O estado Report gera os arquivos suite-name_Report.xml e awsiotdevicetester_report.xml. Esse estado também transmite o relatório para o console.

{
    "Type": "Report",
    "Next": "<state-name>"
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

Você deve sempre fazer a transição para o estado Report próximo ao final do fluxo de execução do teste para que os executores de testes possam visualizar os resultados do teste. Normalmente, o próximo estado após esse estado é Succeed.

Como tratar erros

Se esse estado encontrar problemas com a geração dos relatórios, ele emitirá o erro de execução ReportError.

LogMessage

O estado LogMessage gera o arquivo test_manager.log e transmite a mensagem de log para o console.

{
    "Type": "LogMessage",
    "Next": "<state-name>"
    "Level": "info | warn | error"
    "Message": "<message>"
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

Level

O nível de erro no qual criar a mensagem de log. Se você especificar um nível que não seja válido, esse estado gerará uma mensagem de erro e a descartará.

Message

A mensagem a ser registrada.

SelectGroup

O estado SelectGroup atualiza o contexto da máquina de estados para indicar quais grupos estão selecionados. Os valores definidos por esse estado são usados por qualquer estado Choice subsequente.

{
    "Type": "SelectGroup",
    "Next": "<state-name>"
    "TestGroups": [
        <group-id>"
    ]
}

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Next

O nome do estado para o qual fazer a transição após a execução das ações no estado atual.

TestGroups

Uma matriz de grupos de testes que serão marcados como selecionados. Para cada ID de grupo de testes nessa matriz, a variável group-id_selected é definida como true no contexto. Certifique-se de fornecer IDs de grupos de teste válidos porque o IDT não valida se os grupos especificados existem.

Fail

O estado Fail indica que a máquina de estados não foi executada corretamente. Esse é um estado final para a máquina de estados e cada definição de máquina de estados deve incluir esse estado.

{
    "Type": "Fail"
}

Succeed

O estado Succeed indica que a máquina de estados foi executada corretamente. Esse é um estado final para a máquina de estados e cada definição de máquina de estados deve incluir esse estado.

{
    "Type": "Succeed"
}

Contexto da máquina de estados

O contexto da máquina de estados é um documento JSON somente para leitura que contém dados que estão disponíveis para a máquina de estados durante a execução. O contexto da máquina de estados só é acessível a partir da máquina de estados e contém informações que determinam o fluxo de teste. Por exemplo, você pode usar as informações configuradas pelos executores de teste no arquivo userdata.json para determinar se é necessário executar um teste específico.

O contexto da máquina de estados usa o seguinte formato:

{
    "pool": {
        <device-json-pool-element>
    },
    "userData": {
        <userdata-json-content>
    },
    "config": {
        <config-json-content>
    },
    "suiteFailed": true | false,
    "specificTestGroups": [
        "<group-id>"
    ],
    "specificTestCases": [
        "<test-id>"
    ],
    "hasExecutionErrors": true
}
pool

Informações sobre o grupo de dispositivos selecionado para a execução do teste. Para um grupo de dispositivos selecionados, essas informações são recuperadas a partir do elemento correspondente na matriz do grupo de dispositivos de nível superior definido no arquivo device.json.

userData

Informações no arquivo userdata.json.

config

Pin de informações no arquivo config.json.

suiteFailed

O valor é definido como false quando a máquina de estados é iniciada. Se um grupo de teste falhar em um estado RunTask, esse valor será definido como true pela duração restante da execução da máquina de estados.

specificTestGroups

Se o executor de teste selecionar grupos de teste específicos para execução em vez do pacote de testes todo, essa chave será criada e conterá a lista de IDs de grupos de testes específicos.

specificTestCases

Se o executor de testes selecionar casos de teste específicos para execução em vez do pacote de testes todo, essa chave será criada e conterá a lista de IDs de casos de teste específicos.

hasExecutionErrors

Não sai quando a máquina de estados é iniciada. Se algum estado encontrar um erro de execução, essa variável será criada e definida para true pela duração restante da execução da máquina de estados.

Você pode consultar o contexto usando a notação JSONPath. A sintaxe para consultas JSONPath nas definições de estado é {{$.query}}. Você pode usar consultas JSONPath como strings de espaços reservados em alguns estados. O IDT substitui as strings de espaços reservados pelo valor da consulta JSONPath avaliada no contexto. Você pode usar espaços reservados para os valores a seguir:

  • O valor TestCases em estados RunTask.

  • O valor Expression no estado Choice.

Ao acessar dados do contexto da máquina de estados, verifique se as seguintes condições são atendidas:

  • Seus caminhos JSON devem começar com $.

  • Cada valor deve ser avaliado como uma string, um número ou um booliano.

Para obter mais informações sobre o uso da notação JSONPath para acessar dados do contexto, consulte Use o contexto do IDT.

Erros de execução

Erros de execução são erros na definição da máquina de estado que a máquina de estados encontra ao executar um estado. O IDT registra informações sobre cada erro no arquivo test_manager.log e transmite a mensagem de log para o console.

É possível usar os seguintes métodos para lidar com erros de execução:

Catch

Para usar Catch, adicione o seguinte à sua definição de estado:

"Catch": [
    {    
        "ErrorEquals": [
            "<error-type>"
        ]
        "Next": "<state-name>" 
    }
]

Todos os campos que contêm valores são necessários, conforme descrito aqui:

Catch.ErrorEquals

Uma matriz dos tipos de erro a serem capturados. Se um erro de execução corresponder a um dos valores especificados, a máquina de estados fará a transição para o estado especificado em Catch.Next. Consulte cada definição de estado para obter informações sobre o tipo de erro que ela produz.

Catch.Next

O próximo estado para o qual fazer a transição se o estado atual encontrar um erro de execução que corresponda a um dos valores especificados em Catch.ErrorEquals.

Os blocos Catch são tratados sequencialmente até que um deles corresponda. Se os erros não corresponderem aos listados nos blocos Catch, as máquinas de estados continuarão a ser executadas. Como os erros de execução são resultado de definições de estado incorretas, recomendamos que você faça a transição para o estado Fail quando um estado encontrar um erro de execução.

hasExecutionError

Quando alguns estados encontram erros de execução, além de emitirem o erro, eles também definem o valor hasExecutionError como true no contexto da máquina de estados. Você pode usar esse valor para detectar quando ocorre um erro e, em seguida, usar um estado Choice para fazer a transição da máquina de estados para o estado Fail.

Esse método tem as seguintes características.

  • A máquina de estados não inicia com nenhum valor atribuído a hasExecutionError e esse valor não está disponível até que um determinado estado a defina. Isso significa que você deve definir explicitamente o FallthroughOnError para false para os estados Choice que acessam esse valor para evitar que a máquina de estado seja interrompida se nenhum erro de execução ocorrer.

  • Depois de definido como true, hasExecutionError nunca é definido como falso ou removido do contexto. Isso significa que esse valor só é útil na primeira vez em que é definido como true e, para todos os estados subsequentes, ele não fornece um valor significativo.

  • O valor hasExecutionError é compartilhado com todas as máquinas de estados da ramificação no estado Parallel, o que pode resultar em resultados inesperados, dependendo da ordem em que ela é acessada.

Devido a essas características, não recomendamos que você use esse método se, em vez disso, puder usar um bloco Catch.

Exemplo de máquinas de estados

Esta seção fornece alguns exemplos de configurações de máquinas de estados.

Exemplo de máquina de estados: execute um único grupo de testes

Esta máquina de estados:

  • executa o grupo de testes com id GroupA, que deve estar presente no pacote em um arquivo group.json.

  • Verifica se há erros de execução e transições para Fail se algum foi encontrado.

  • Gera um relatório e faz a transição para Succeed se não houver erros eFail, caso contrário.

{
    "Comment": "Runs a single group and then generates a report.",
    "StartAt": "RunGroupA",
    "States": {
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "Report",
            "TestGroup": "GroupA",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemplo de máquina de estados: executa grupos de testes selecionados pelo usuário

Esta máquina de estados:

  • verifica se o executor do teste selecionou grupos de testes específicos. A máquina de estados não verifica casos de teste específicos porque os executores de testes não podem selecionar casos de teste sem também selecionar um grupo de testes.

  • Se os grupos de testes forem selecionados:

    • executa os casos de teste nos grupos de testes selecionados. Para fazer isso, a máquina de estados não especifica explicitamente nenhum grupo de testes ou caso de teste no estado RunTask.

    • Gera um relatório após executar todos os testes e saídas.

  • Se os grupos de testes não forem selecionados:

    • executa testes em grupo de testes GroupA.

    • Gera relatórios e saídas.

{
    "Comment": "Runs specific groups if the test runner chose to do that, otherwise runs GroupA.",
    "StartAt": "SpecificGroupsCheck",
    "States": {
        "SpecificGroupsCheck": {
            "Type": "Choice",
            "Default": "RunGroupA",
            "FallthroughOnError": true,
            "Choices": [
                {
                    "Expression": "{{$.specificTestGroups[0]}} != ''",
                    "Next": "RunSpecificGroups"
                }
            ]
        },
        "RunSpecificGroups": {
            "Type": "RunTask",
            "Next": "Report",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "Report",
            "TestGroup": "GroupA",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemplo de máquina de estados: executa um único grupo de testes com atributos do produto

Esta máquina de estados:

  • executa o grupo de testes GroupA.

  • Verifica se há erros de execução e transições para Fail se algum foi encontrado.

  • Adiciona o atributo FeatureThatDependsOnGroupA ao arquivo awsiotdevicetester_report.xml:

    • Se GroupA for aprovado, o atributo será definido como supported.

    • O atributo não será marcado como opcional no relatório.

  • Gera um relatório e faz a transição para Succeed se não houver erros e Fail, caso contrário.

{
    "Comment": "Runs GroupA and adds product features based on GroupA",
    "StartAt": "RunGroupA",
    "States": {
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "AddProductFeatures",
            "TestGroup": "GroupA",
            "ResultVar": "GroupA_passed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "AddProductFeatures": {
            "Type": "AddProductFeatures",
            "Next": "Report",
            "Features": [
                {
                    "Feature": "FeatureThatDependsOnGroupA",
                    "Groups": [
                        "GroupA"
                    ],
                    "IsRequired": true
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemplo de máquina de estado: execute dois grupos de teste em paralelo

Esta máquina de estados:

  • Executa os grupos de teste GroupA e GroupB em paralelo. As variáveis ResultVar armazenadas no contexto pelos RunTask estados nas máquinas de estado da ramificação estão disponíveis para o estado AddProductFeatures.

  • Verifica se há erros de execução e transições para Fail se algum foi encontrado. Essa máquina de estado não usa um bloco Catch porque esse método não detecta erros de execução em máquinas de estado de ramificação.

  • Adiciona atributos ao arquivo awsiotdevicetester_report.xml com base nos grupos que passam

    • Se GroupA for aprovado, o atributo será definido como supported.

    • O atributo não será marcado como opcional no relatório.

  • Gera um relatório e faz a transição para Succeed se não houver erros e Fail, caso contrário.

Se dois dispositivos estiverem configurados no grupo de dispositivos, GroupA e GroupB poderão ser executados ao mesmo tempo. No entanto, se GroupA ou GroupB tiver vários testes, os dois dispositivos poderão ser alocados para esses testes. Se somente um dispositivo estiver configurado, os grupos de testes serão executados sequencialmente.

{
    "Comment": "Runs GroupA and GroupB in parallel",
    "StartAt": "RunGroupAAndB",
    "States": {
        "RunGroupAAndB": {
            "Type": "Parallel",
            "Next": "CheckForErrors",
            "Branches": [
                {
                    "Comment": "Run GroupA state machine",
                    "StartAt": "RunGroupA",
                    "States": {
                        "RunGroupA": {
                            "Type": "RunTask",
                            "Next": "Succeed",
                            "TestGroup": "GroupA",
                            "ResultVar": "GroupA_passed",
                            "Catch": [
                                {
                                    "ErrorEquals": [
                                        "RunTaskError"
                                    ],
                                    "Next": "Fail"
                                }
                            ]
                        },
                        "Succeed": {
                            "Type": "Succeed"
                        },
                        "Fail": {
                            "Type": "Fail"
                        }
                    }
                },
                {
                    "Comment": "Run GroupB state machine",
                    "StartAt": "RunGroupB",
                    "States": {
                        "RunGroupA": {
                            "Type": "RunTask",
                            "Next": "Succeed",
                            "TestGroup": "GroupB",
                            "ResultVar": "GroupB_passed",
                            "Catch": [
                                {
                                    "ErrorEquals": [
                                        "RunTaskError"
                                    ],
                                    "Next": "Fail"
                                }
                            ]
                        },
                        "Succeed": {
                            "Type": "Succeed"
                        },
                        "Fail": {
                            "Type": "Fail"
                        }
                    }
                }
            ]
        },
        "CheckForErrors": {
            "Type": "Choice",
            "Default": "AddProductFeatures",
            "FallthroughOnError": true,
            "Choices": [
                {
                    "Expression": "{{$.hasExecutionErrors}} == true",
                    "Next": "Fail"
                }
            ]
        },
        "AddProductFeatures": {
            "Type": "AddProductFeatures",
            "Next": "Report",
            "Features": [
                {
                    "Feature": "FeatureThatDependsOnGroupA",
                    "Groups": [
                        "GroupA"
                    ],
                    "IsRequired": true
                },
                {
                    "Feature": "FeatureThatDependsOnGroupB",
                    "Groups": [
                        "GroupB"
                    ],
                    "IsRequired": true
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}