Configurar a máquina de estado IDT - AWS IoT Greengrass
Formato de máquina de estadoDefinições de estados e estados válidosContexto de 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 IDT

Importante

A partir do IDT v4.5.1, esta máquina de estado está obsoleta. Recomendamos que você utilize o novo orquestrador de teste. Para obter mais informações, consulteConfigurar o orquestrador de teste IDT

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

Se o conjunto de testes 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 corredores de teste a capacidade de selecionar e executar grupos de teste específicos, em vez de todo o conjunto de testes.

  • Se grupos de teste específicos não forem selecionados, executa todos os grupos de teste na suíte 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 teste e caso de teste.

A máquina de estado para um conjunto de testes IDT deve atender aos seguintes critérios:

  • Cada estado corresponde a uma ação para o IDT executar, como executar um grupo de teste ou produto 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 serSucceedouFail.

Formato de máquina de estado

Você pode usar o seguinte modelo para configurar o seu próprio<custom-test-suite-folder>/suite/state_machine.jsonfile: 

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

Nome do estado no qual o IDT começa a executar o conjunto de testes. O valor deStartAtDeve ser definido como um dos estados listados noStatesobjeto.

States

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

OStatesobjeto deve incluir oSucceedeFailEstados. Para obter informações sobre estados válidos, consulteDefinições de estados e estados válidos.

Definições de estados e estados válidos

Esta seção descreve as definições de estado de todos os estados válidos que podem ser usados na máquina de estado IDT. Alguns dos seguintes estados oferecem suporte a configurações no nível do caso de teste. No entanto, recomendamos que você configure 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

ORunTaskO state executa casos de teste de um grupo de teste definido no conjunto 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

Nome do estado para o qual deve mudar após a execução das ações no estado atual.

TestGroup

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

TestCases

Opcional. Uma matriz de IDs de caso de teste do grupo especificado emTestGroup. Com base nos valores deTestGroupeTestCases, IDT determina o comportamento de execução do teste da seguinte forma:

  • Quando ambosTestGroupeTestCasessão especificados, o IDT executa os casos de teste especificados do grupo de teste.

  • QuandoTestCasessão especificados, masTestGroupnão é especificado, o IDT executa os casos de teste especificados.

  • QuandoTestGroupé especificado, masTestCasesNão é especificado, o IDT executa todos os casos de teste no grupo de teste especificado.

  • Quando nenhum dos doisTestGroupouTestCasesé especificado, o IDT executa todos os casos de teste do grupo de teste que o executor de teste seleciona da IDT CLI. Para habilitar a seleção de grupo para corredores de teste, você deve incluir ambosRunTaskeChoiceestados em seustate_machine.jsonfile. Para obter um exemplo de como isso funciona, consulteExemplo de máquina de estado do: Execute grupos de teste selecionados pelo usuário.

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

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. IDT define o valor da variável que você define emResultVarparatrueoufalseCom base no seguinte:

  • Se o nome da variável for do formuláriotext_text_passed, então o valor é definido para se todos os testes no primeiro grupo de teste passaram ou foram ignorados.

  • Em todos os outros casos, o valor é definido para se todos os testes em todos os grupos de teste passaram ou foram ignorados.

Normalmente, você vai usarRunTaskstate 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 parallel, em uma ordem aleatória. No entanto, se todos os casos de teste exigirem que um dispositivo seja executado e apenas um único dispositivo estiver disponível, os casos de teste serão executados sequencialmente.

Como tratar erros

Se algum dos grupos de teste ou IDs de caso de teste especificados não for válido, esse estado emitirá oRunTaskErrorErro de execução do. Se o estado encontrar um erro de execução, ele também definirá ohasExecutionErrorvariável no contexto da máquina de estado paratrue.

Choice

OChoicestate permite definir dinamicamente o próximo estado para 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 deve mudar se nenhuma das expressões definidas noChoicespode ser avaliado paratrue.

FallthroughOnError

Opcional. Especifica o comportamento quando o estado encontra um erro na avaliação de expressões. Definido comotruese você quiser pular uma expressão se a avaliação resultar em um erro. Se nenhuma expressão corresponder, a máquina de estado muda para oDefaultEstado. Se oFallthroughOnErrorO valor não é especificado, o padrão éfalse.

Choices

Uma matriz de expressões e estados para determinar para qual estado fazer a transição após a execução das ações no estado atual.

Choices.Expression

Uma string de expressão que avalia como um valor booleano. Se a expressão for avaliada comotrue, depois a máquina de estado muda para o estado definido noChoices.Next. As strings de expressão recuperam valores do contexto da máquina de estado e, em seguida, executam operações nelas para chegar a um valor booleano. Para obter informações sobre como acessar o contexto da máquina de estado, consulteContexto de máquina de estado.

Choices.Next

Nome do estado para o qual deve mudar se a expressão definida noChoices.Expressionavalia paratrue.

Como tratar erros

OChoicestate pode exigir 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 umCatchBloquear para lidar com erros nesse estado. Se você quiser parar de executar a máquina de estado quando ela encontrar um erro, você deve definirFallthroughOnErrorparafalse. No entanto, recomendamos que você definaFallthroughOnErrorparatrueE, dependendo do seu caso de uso, siga um destes procedimentos:

  • Se uma variável que você está acessando não exista em alguns casos, use o valor deDefaulte adicionalChoicesBlocos para especificar o próximo estado.

  • Se uma variável que você está acessando sempre existir, defina aDefaultEstado paraFail.

Parallel

OParallelstate permite definir e executar novas máquinas de estado em parallel entre si.

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

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

Next

Nome do estado para o qual deve mudar após a execução das ações no estado atual.

Branches

Uma matriz de definições de máquina de estado a ser executada. Cada definição de máquina de estado deve conter a sua própriaStartAt,Succeed, eFailEstados. As definições de máquina de estado nesta matriz não podem fazer referência a estados fora de sua própria definição.

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 ler essas variáveis de outra ramificação pode resultar em comportamento inesperado.

OParallelstate se move para o próximo estado somente depois que ele executa todas as máquinas de estado de ramificação. Cada estado que requer um dispositivo aguardará a execução 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 parallel. Se dispositivos suficientes não estiverem disponíveis, os casos de teste serão executados sequencialmente. Como os casos de teste são executados em uma ordem aleatória quando são executados em parallel, dispositivos diferentes podem ser usados para executar testes do mesmo grupo de teste.

Como tratar erros

Certifique-se de que tanto a máquina de estado de ramificação quanto a máquina de estado pai façam a transição para oFailstate para lidar com 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 pai, você não pode usar umCatchbloco para lidar com erros de execução em máquinas de estado de ramificação. Em vez disso, use ohasExecutionErrorsvalor no contexto da máquina de estado compartilhado. Para obter um exemplo de como isso funciona, consulteExemplo de máquina de estado do: Execute dois grupos de teste em parallel.

AddProductFeatures

OAddProductFeaturesstate permite adicionar recursos do produto aoawsiotdevicetester_report.xmlarquivo gerado pelo IDT.

Um recurso do produto são informações definidas pelo usuário sobre critérios específicos que um dispositivo pode atender. Por exemplo, as receitasMQTTrecurso do produto pode designar que o dispositivo publica mensagens MQTT corretamente. No relatório, os recursos do produto são definidos comosupported,not-supportedou um valor personalizado, com base na aprovação dos testes especificados.

nota

OAddProductFeaturesstate não gera relatórios por si só. Esse estado deve fazer a transição para oReportestadopara 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

Nome do estado para o qual deve mudar após a execução das ações no estado atual.

Features

Uma variedade de recursos do produto para mostrar naawsiotdevicetester_report.xmlfile.

Feature

O nome do recurso

FeatureValue

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

Se você usar um valor personalizado paraFeatureValue, você pode testar o mesmo recurso com condições diferentes, e o IDT concatena os valores de feição para as condições suportadas. Por exemplo, o trecho a seguir mostra oMyFeaturerecurso com dois valores de feição separados:

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

Se ambos os grupos de teste passarem, o valor do recurso será definido comofirst-feature-supported, second-feature-supported.

Groups

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

OneOfGroups

Opcional. Uma matriz de IDs de grupos de testes. Todos os testes em pelo menos um dos grupos de teste especificados devem passar para que o recurso seja suportado.

TestCases

Opcional. Uma matriz de IDs de casos de teste. Se você especificar esse valor, então o seguinte se aplicará:

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

  • GroupsDeve conter apenas um ID do grupo de teste.

  • OneOfGroupsNão deve ser especificado.

IsRequired

Opcional. Definido comofalsepara marcar esse 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 aoprotocolvalor especificado nodevice.jsonfile. Se esse valor for especificado, os corredores de teste deverão especificar umprotocolvalor que corresponde 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 aAddProductFeaturesstate, você deve definir o valor deResultVarnoRunTaskState para um dos seguintes valores:

  • Se você especificou IDs de caso de teste individuais, definaResultVarparagroup-id_test-id_passed.

  • Se você não especificou IDs de caso de teste individuais, definaResultVarparagroup-id_passed.

OAddProductFeaturesVerificações de estado para os resultados do teste da seguinte maneira:

  • Se você não especificou nenhuma IDs de caso de teste, o resultado de cada grupo de teste será determinado a partir do valor dogroup-id_passedvariável no contexto da máquina de estado.

  • Se você especificou IDs de caso de teste, o resultado de cada um dos testes será determinado a partir do valor dogroup-id_test-id_passedvariável no contexto da máquina de estado.

Como tratar erros

Se uma ID de grupo fornecida nesse estado não for uma ID de grupo válida, esse estado resultará naAddProductFeaturesErrorErro de execução do. Se o estado encontrar um erro de execução, ele também definirá ohasExecutionErrorsvariável no contexto da máquina de estado paratrue.

Relatório

OReportO estado gera osuite-name_Report.xmleawsiotdevicetester_report.xmlarquivos. 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

Nome do estado para o qual deve mudar após a execução das ações no estado atual.

Você sempre deve fazer a transição para oReportestado no final do fluxo de execução do teste para que os corredores de teste 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 emite oReportErrorErro de execução do.

LogMessage

OLogMessageO estado gera otest_manager.logArquivo 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

Nome do estado para o qual deve mudar após a execução das ações no estado atual.

Level

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

Message

A mensagem para registrar.

SelectGroup

OSelectGroupstate 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 subseqüenteChoiceEstados.

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

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

Next

Nome do estado para o qual deve mudar 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, ogroup-id_selectedvariável está definida comotrueno contexto. Certifique-se de fornecer IDs de grupo de teste válidos porque o IDT não valida se os grupos especificados existem.

Fail

OFailstate indica que a máquina de estado não foi executada corretamente. Este é um estado final para a máquina de estado, e cada definição de máquina de estado deve incluir esse estado.

{
    "Type": "Fail"
}

Succeed

OSucceedstate indica que a máquina de estado foi executada corretamente. Este é um estado final para a máquina de estado, e cada definição de máquina de estado deve incluir esse estado.

{
    "Type": "Succeed"
}

Contexto de máquina de estado

O contexto da máquina de estado é um documento JSON somente leitura que contém dados disponíveis para a máquina de estado durante a execução. O contexto da máquina de estado só é acessível a partir da máquina de estado e contém informações que determinam o fluxo de teste. Por exemplo, você pode usar informações configuradas por corredores de teste nauserdata.jsonarquivo para determinar se um teste específico é necessário para ser executado.

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 pool de dispositivos selecionado para a execução de teste. Para um pool de dispositivos selecionado, essas informações são recuperadas do elemento de matriz de pool de dispositivos de nível superior correspondente definido nadevice.jsonfile.

userData

Informações nouserdata.jsonfile.

config

Informações do fixar oconfig.jsonfile.

suiteFailed

O valor é definido comofalseQuando a máquina de estado for iniciada. Se um grupo de teste falhar em umRunTaskstate, então esse valor é definido comotruePara a duração restante da execução da máquina de estado.

specificTestGroups

Se o executor de teste selecionar grupos de teste específicos a serem executados em vez de todo o conjunto de testes, essa chave será criada e contém a lista de IDs de grupos de teste específicos.

specificTestCases

Se o executor de teste selecionar casos de teste específicos a serem executados em vez de todo o conjunto de testes, essa chave será criada e contém a lista de IDs de casos de teste específicos.

hasExecutionErrors

Não sai quando a máquina de estado é iniciada. Se algum estado encontrar erros de execução, essa variável será criada e definida comotruePara a duração restante da execução da máquina de estado.

Você pode consultar o contexto usando a notação JSONPath. A sintaxe para consultas JSONPath em definições de estado é{{$.query}}. Você pode usar consultas JSONPath como cadeias de espaço reservado em alguns estados. O IDT substitui as strings de espaço reservado pelo valor da consulta JSONPath avaliada a partir do contexto. É possível usar espaços reservados para os seguintes valores:

  • OTestCasesvalor emRunTaskEstados.

  • OExpressionvalorChoiceEstado.

Quando você 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 para uma string, um número ou um booleano.

Para obter mais informações sobre como usar a notação JSONPath para acessar dados do contexto, consulteUsar o contexto 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 estado encontra ao executar um estado. O IDT registra informações sobre cada erro notest_manager.logArquivo e transmite a mensagem de log para o console.

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

Captura

Para usarCatch, adicione o seguinte à 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 muda para o estado especificado noCatch.Next. Consulte cada definição de estado para obter informações sobre o tipo de erro que ele produz.

Catch.Next

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

Blocos de captura são manipulados sequencialmente até que um corresponda. Se os erros não corresponderem aos listados nos blocos Catch, as máquinas de estado continuarão sendo 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 emitir o erro, eles também definem ohasExecutionErrorvalor paratrueno contexto da máquina de estado. Você pode usar esse valor para detectar quando ocorre um erro e, em seguida, usar umChoicestate para fazer a transição da máquina de estado para oFailEstado.

Esse método tem as seguintes características.

  • A máquina de estado não inicia com nenhum valor atribuído ahasExecutionError, e esse valor não estará disponível até que um determinado estado o defina. Isso significa que você deve definir explicitamente oFallthroughOnErrorparafalsepara aChoiceafirma que acessam esse valor para impedir que a máquina de estado pare se não ocorrerem erros de execução.

  • Uma vez definido comotrue,hasExecutionErrornunca é definido como falso ou removido do contexto. Isso significa que esse valor é útil somente na primeira vez que é definido comotrue, e para todos os estados subsequentes, ele não fornece um valor significativo.

  • OhasExecutionErrorvalor é compartilhado com todas as máquinas de estado de ramificação naParallelstate, que pode resultar em resultados inesperados dependendo da ordem em que ele é acessado.

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

Exemplo de máquinas de estado

Esta seção fornece algumas configurações de máquina de estado de exemplo.

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

Esta máquina de estado do:

  • Executa o grupo de teste com idGroupA, que deve estar presente na suíte em umgroup.jsonfile.

  • Verifica se há erros de execução e transições paraFailse algum for encontrado.

  • Gera um relatório e faz a transição paraSucceedse não houver erros, eFailCaso 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 estado do: Execute grupos de teste selecionados pelo usuário

Esta máquina de estado do:

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

  • Se os grupos de testes forem selecionados:

    • Executa os casos de teste dentro dos grupos de teste selecionados. Para fazer isso, a máquina de estado não especifica explicitamente nenhum grupo de teste ou casos de teste noRunTaskEstado.

    • Gera um relatório depois de executar todos os testes e saídas.

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

    • Executa testes no grupo de testeGroupA.

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

Esta máquina de estado do:

  • Executa o grupo de testesGroupA.

  • Verifica se há erros de execução e transições paraFailse algum for encontrado.

  • Adiciona oFeatureThatDependsOnGroupArecurso para oawsiotdevicetester_report.xmlfile:

    • SeGroupApassa, o recurso está definido comosupported.

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

  • Gera um relatório e faz a transição paraSucceedse não houver erros, eFailde outra forma

{
    "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 do: Execute dois grupos de teste em parallel

Esta máquina de estado do:

  • Executa oGroupAeGroupBgrupos de teste em parallel. OResultVarvariáveis armazenadas no contexto peloRunTaskestados nas máquinas de estado de ramificação por estão disponíveis para oAddProductFeaturesEstado.

  • Verifica se há erros de execução e transições paraFailse algum for encontrado. Esta máquina de estado não usa umCatchbloco porque esse método não detecta erros de execução em máquinas de estado de ramificação.

  • Adiciona recursos aoawsiotdevicetester_report.xmlarquivo com base nos grupos que passam

    • SeGroupApassa, o recurso está definido comosupported.

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

  • Gera um relatório e faz a transição paraSucceedse não houver erros, eFailde outra forma

Se dois dispositivos estiverem configurados no pool de dispositivos, ambosGroupAeGroupBPode ser executado ao mesmo tempo. No entanto, se um dos doisGroupAouGroupBtem vários testes nele, então ambos os dispositivos podem ser alocados para esses testes. Se apenas um dispositivo estiver configurado, os grupos de teste 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"
        }
    }
}