Configurar a máquina de estado do IDT - Gratuito RTOS
Formato da máquina de estadoEstados válidos e definições de estadoContexto da máquina de estadoErros de execuçãoExemplo de máquinas de estado

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

Configurar a máquina de estado do IDT

Importante

Desde o IDT v4.5.2, esta máquina de estado está obsoleta. É muito recomendado o uso do novo orquestrador de testes. Para ter mais informações, consulte Configure o orquestrador de testes do IDT.

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

Se seu pacote de teste não incluir uma máquina de estado definida pelo usuário, o IDT gerará uma máquina de estado para você. A máquina de estado padrão 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 teste.

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

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

A máquina de estado de um pacote de teste da IDT deve atender aos seguintes critérios:

  • Cada estado corresponde a uma ação a ser executada pelo IDT, como executar um grupo de teste 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 estado

É possível 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 estado.

StartAt

O nome do estado em que o IDT começa a executar o pacote de teste. 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 IDT válidos. Cada objeto de estados .state-name contém a definição de um estado válido mapeado para o nome do estado.

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 IDT. Alguns dos estados a seguir são compatíveis com configurações no nível do caso de teste. No entanto, é recomendado configurar as regras de transição de estado no nível do grupo de teste em vez do 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 teste.

{
    "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 teste a ser executado. Se este valor não for especificado, o IDT executará o grupo de teste selecionado pelo executor de testes.

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 tanto o TestGroup como os 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 são especificados, o IDT executa os casos de teste especificados.

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

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

    Para obter mais informações sobre como habilitar os comandos da CLI no IDT, consulte Habilitar comandos da CLI no IDT.

ResultVar

O nome da variável de contexto a ser definida com os resultados da execução do teste. Não especifique este valor se você não especificou um valor para TestGroup. 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 foram aprovados ou ignorados.

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

Normalmente, você usará o estado RunTask para especificar um ID de grupo de teste sem especificar IDs de caso de teste individuais, para que o IDT execute todos os casos de teste no grupo de teste 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 em sequência.

Como tratar erros

Se algum dos grupos de teste 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 estado como true.

Escolha

O estado Choice permite definir dinamicamente o próximo estado para o qual fazer a transição com base em 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 se depara com um erro na avaliação de expressões. Defina como true se deseja ignorar uma expressão, caso a avaliação resulte em um erro. Se não houver correspondência de expressão, a máquina de estado fará a transição para o estado Default. Se o valor FallthroughOnError não for especificado, o valor padrão será false.

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ão que deve ser avaliada para um valor booleano. Se a expressão for avaliada como true, a máquina de estado fará a transição para o estado definido em Choices.Next. As strings de expressão recuperam valores do contexto da máquina de estado e executam operações neles para chegar a um valor booleano. Para obter informações sobre como acessar o contexto da máquina de estado, consulte Contexto da máquina de estado.

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 o tratamento de erros nos seguintes casos:

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

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

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

Não é possível usar um bloco Catch para tratar erros nesse estado. Se quiser parar de executar a máquina de estado quando ela encontrar um erro, defina FallthroughOnError como false. No entanto, é recomendado configurar FallthroughOnError e true, e dependendo do seu caso de uso, executar uma das seguintes etapas:

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

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

Paralelo

O estado Parallel permite que você defina e execute novas máquinas de estado em paralelo.

{
    "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 estado a serem executadas. Cada definição de máquina de estado deve conter os próprios estados StartAt, Succeed e Fail. As definições de máquina de estado nesta matriz não podem fazer referência a estados de fora da definição deles.

nota

Como cada máquina de estado de ramificação compartilha o mesmo contexto de máquina de estado, definir variáveis em uma ramificação e depois lê-las de 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 estado da ramificação. Todo estado que necessita um dispositivo aguardará para ser executado até que o dispositivo esteja disponível. Se vários dispositivos estiverem disponíveis, este estado executará casos de teste a partir de vários grupos em paralelo. Se não houver dispositivos suficientes disponíveis, os casos de teste serão executados em sequência. Como os casos de teste são executados em uma ordem aleatória quando executados em paralelo, podem ser usados dispositivos diferentes para executar testes a partir do mesmo grupo de teste.

Como tratar erros

Certifique-se que tanto a máquina de estado da ramificação quanto a máquina de estado pai fazem 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 estado de ramificação. Em vez disso, use o valor hasExecutionErrors no contexto da máquina de estado compartilhada. Para obter um exemplo de como isso funciona, consulte Exemplo de máquina de estado: execute dois grupos de testes em paralelo.

AddProductFeatures

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

Um recurso do produto é uma informação definida pelo usuário sobre critérios específicos que um dispositivo pode atender. Por exemplo, o recurso do produto MQTT pode indicar que o dispositivo publica mensagens MQTT corretamente. No relatório, os recursos 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 por conta própria. Esse estado deve passar 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 recursos do produto para mostrar no arquivo awsiotdevicetester_report.xml.

Feature

O nome do recurso

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 recurso será definido como supported ou not-supported.

Se você usar um valor personalizado para FeatureValue, poderá testar o mesmo recurso com condições diferentes e o IDT concatenará os valores do recurso para as condições compatíveis. Por exemplo, o trecho a seguir mostra o recurso MyFeature com dois valores de recurso 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 recurso será definido como first-feature-supported, second-feature-supported.

Groups

Opcional. Uma matriz de IDs de grupos de teste. Todos os testes dentro de cada grupo de teste especificado devem ser aprovados para que o recurso seja compatível.

OneOfGroups

Opcional. Uma matriz de IDs de grupos de teste. Todos os testes dentro de pelo menos um dos grupos de teste especificados devem ser aprovados para que o recurso seja compatível.

TestCases

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

  • Todos os casos de teste especificados devem ser aprovados para que o recurso seja compatível.

  • Groups deve conter somente um ID de grupo de teste.

  • OneOfGroups não deve ser especificado.

IsRequired

Opcional. Defina como false para marcar este recurso como um recurso 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 recurso no relatório. Se esse valor não for especificado, o recurso 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 especificou IDs de casos de teste individuais, defina ResultVar como group-id_test-id_passed.

  • Se 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 não especificou IDs de casos de teste, o resultado de cada grupo de teste será determinado a partir do valor da variável group-id_passed no contexto da máquina de estado.

  • Se 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 estado.

Como tratar erros

Se um ID de grupo fornecido neste estado não for um ID de grupo válido, este 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 estado como true.

Relatório

O estado Report gera os arquivos suite-name_Report.xml e awsiotdevicetester_report.xml. Este 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.

É sempre necessário fazer a transição para o estado Report perto do final do fluxo de execução do teste para que os executores de teste possam visualizar os resultados do teste. Normalmente, o próximo estado após este estado é Succeed.

Como tratar erros

Se este estado se deparar com problemas ao gerar 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 especificar um nível que não seja válido, este estado irá 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 estado para indicar quais grupos estão selecionados. Os valores definidos por esse estado são usados por qualquer estado Choice seguinte.

{
    "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 teste que serão marcados como selecionados. Para cada ID de grupo de teste nesta 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.

Falha

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

{
    "Type": "Fail"
}

Êxito

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

{
    "Type": "Succeed"
}

Contexto da máquina de estado

O contexto da máquina de estado é um documento JSON somente para leitura que contém dados que estão disponíveis para a máquina de estado durante a execução. O contexto da máquina de estado é acessível somente da máquina de estado 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 estado 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 selecionado, essas informações são recuperadas do elemento correspondente da matriz do grupo de dispositivos de nível superior definido no arquivo device.json.

userData

As informações no arquivo userdata.json.

config

As informações fixadas no arquivo config.json.

suiteFailed

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

specificTestGroups

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

specificTestCases

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

hasExecutionErrors

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

É possível 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ço reservado em alguns estados. O IDT substitui as strings de espaço reservado pelo valor da consulta JSONPath avaliada no contexto. É possível usar espaços reservados para os seguintes valores:

  • O valor TestCases nos estados RunTask.

  • O valor de Expression no estado Choice.

Ao acessar dados do contexto da máquina de estado, 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 booleano.

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

Os erros de execução são erros na definição da máquina de estado que a máquina de estado 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 estado 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 corresponder a um dos valores especificados em Catch.ErrorEquals.

Os blocos de captura são manuseados de maneira sequencial até que um deles corresponda. Se os erros não corresponderem aos listados nos blocos Catch, as máquinas de estado 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 Falha 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 estado. É possível usar este valor para detectar quando ocorre um erro e, em seguida, usar um estado Choice para fazer a transição da máquina de estado para o estado Fail.

Este método tem as características a seguir.

  • A máquina de estado não inicia com nenhum valor atribuído para hasExecutionError e este valor não está disponível até que um determinado estado a defina. Isto significa que é preciso definir explicitamente o FallthroughOnError como false para os estados Choice que acessam este valor para evitar que a máquina de estado pare se nenhum erro de execução ocorrer.

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

  • O valor hasExecutionError é compartilhado com todas as máquinas de estado da filial no estadoParallel, o que pode resultar em resultados inesperados, dependendo da ordem em que é acessado.

Por conta dessas características, não é recomendado usar este método, e sim, usar um bloco Catch.

Exemplo de máquinas de estado

Esta seção fornece alguns exemplos de configurações de máquina de estado.

Exemplo de máquina de estado: execute um único grupo de teste

Esta máquina de estado:

  • Executa o grupo de teste com o ID GroupA, que deve estar presente no pacote em um arquivo group.json.

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

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

{
    "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 estado: execute grupos de teste selecionados pelo usuário

Esta máquina de estado:

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

  • Se os grupos de teste forem selecionados:

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

    • Gera um relatório após executar todos os testes e sai.

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

    • Executa testes no grupo de teste GroupA.

    • Gera relatórios e sai.

{
    "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 estado: execute um único grupo de teste com recursos do produto

Esta máquina de estado:

  • Executa o grupo de teste GroupA.

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

  • Adiciona o recurso FeatureThatDependsOnGroupA ao arquivo awsiotdevicetester_report.xml:

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

    • O recurso não está marcado como opcional no relatório.

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

{
    "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 testes em paralelo

Esta máquina de estado:

  • Executa os grupos de teste GroupA e GroupB em paralelo. As variáveis ResultVar armazenadas no contexto pelos estados RunTask 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 de Fail para ver se algum foi encontrado. Esta máquina de estado não usa um bloco Catch porque este método não detecta erros de execução em máquinas de estado de ramificação.

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

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

    • O recurso não está marcado como opcional no relatório.

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

Se dois dispositivos estiverem configurados no grupo de dispositivos, tanto o GroupA como o GroupB poderão ser executados ao mesmo tempo. No entanto, se um 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 teste serão executados em sequência.

{
    "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"
        }
    }
}