Como executar testes automatizados para seus jogos com o Unity Test Framework

Esta página da Web foi automaticamente traduzida para sua conveniência. Não podemos garantir a precisão ou a confiabilidade do conteúdo traduzido. Se tiver dúvidas sobre a precisão do conteúdo traduzido, consulte a versão oficial em inglês da página da Web.

Clique aqui.

No desenvolvimento de jogos, os testes manuais podem rapidamente se tornar repetitivos e propensos a erros. Você já se viu em um desses ciclos de teste aparentemente intermináveis enquanto trabalha em um novo recurso ou tenta corrigir um bug?

Ao automatizar seus testes de código, você pode passar mais tempo no desenvolvimento criativo de jogos e menos em tarefas repetitivas (mas importantes) de QA que garantem que adicionar, remover ou alterar código não quebre seu projeto.

Unity ajuda você a criar, gerenciar e executar testes automatizados para seus jogos com o Unity Test Framework.

Testar de duas maneiras no Unity Test Framework

O Unity Test Framework (UTF) permite que você teste o código do seu projeto em ambos os modos Edit e Play. Você também pode direcionar o código de teste para várias plataformas, como standalone, iOS ou Android.

O UTF é instalado adicionando-o ao seu projeto com o Package Manager.

Nos bastidores, o UTF se integra ao NUnit, que é uma biblioteca de testes de código aberto bem conhecida para linguagens .NET.

Existem duas categorias principais de testes que você pode escrever com o UTF, modo de edição e modo de reprodução:

Os testes de Edit mode são executados no Editor do Unity e têm acesso ao código do Editor e do jogo. Isso significa que você pode testar suas extensões personalizadas do Editor ou usar testes para modificar configurações no Editor e entrar no modo de reprodução, o que é útil para ajustar valores do Inspector e, em seguida, executar testes automatizados com muitas configurações diferentes.

Os testes de Play mode permitem que você exerça seu código de jogo em tempo de execução. Os testes são geralmente executados como coroutines usando o atributo [UnityTest]. Isso permite que você teste código que pode ser executado em vários quadros. Por padrão, os testes do modo de reprodução serão executados no Editor, mas você também pode executá-los em uma build de player standalone para várias plataformas de destino.

testes automatizados — O pacote Third Person Character Controller, disponível na Unity Asset Store

Como testar o Unity Test Framework

Para acompanhar este exemplo, você precisará instalar o Starter Assets – Third Person Character Controller package da Unity Asset Store e importá-lo em um novo projeto.

Configurando o Unity Test Framework

Instale o UTF via Window > Package Manager. Pesquise por Test Framework no Registro Unity no Gerenciador de Pacotes. Certifique-se de selecionar a versão 1.3.3 (a versão mais recente no momento da escrita).

Uma vez que o UTF esteja instalado, abra o arquivo Packages/manifest.json com um editor de texto e adicione uma seção testables após dependencies, assim:

,
"testables": [
"com.unity.inputsystem"
]

Salve o arquivo. Isso será útil mais tarde, quando você precisará referenciar a assembly Unity.InputSystem.TestFramework para testar e emular a entrada do jogador.

Volte para o Editor e permita que a versão mais recente seja instalada.

Definições de assembly de teste

Clique em Window > General > Test Runner para visualizar a janela do editor Test Runner.

Nesta parte do tutorial, o foco será na criação de testes em modo Play. Em vez de usar as opções Criar Pasta de Assembly de Teste na Janela do Test Runner, você as criará usando a janela do Projeto.

Com a raiz da sua pasta de Assets do Projeto destacada, clique com o botão direito e escolha Create > Testing > Tests Assembly Folder.

Uma pasta de projeto Tests é adicionada, contendo um arquivo Tests.asmdef (definição de assembly). Isso é necessário para que os testes referenciem seus módulos de jogo e dependências.

O código do Character Controller será referenciado nos testes e também precisará de uma definição de assembly. Em seguida, você configurará algumas definições de montagem e referências para facilitar os testes entre os módulos.

Clique com o botão direito na pasta do projeto Assets/StarterAssets/InputSystem e escolha Criar > Definição de Montagem. Dê um nome descritivo, por exemplo StarterAssetsInputSystem.

Selecione o novo arquivo StarterAssetsInputSystem.asmdef e, usando o Inspetor, adicione uma Referência de Definição de Montagem para Unity.InputSystem. Clique em Aplicar.

Clique com o botão direito na pasta do projeto Assets/StarterAssets/ThirdPersonController/Scripts e escolha Criar > Definição de Montagem. Dê um nome descritivo, por exemplo ThirdPersonControllerMain.

Como você fez com a definição de montagem anterior, abra ThirdPersonControllerMain no Inspetor e selecione referências para:

- Unity.InputSystem

- StarterAssetsInputSystem

Clique em Aplicar.

Adição de referências a definições de montagem

Para emular partes do Sistema de Entrada, você precisará referenciá-lo em seus testes. Além disso, você precisará referenciar o namespace StarterAssets em uma montagem que você criará para o código do Controlador de Terceira Pessoa.

Abra Tests.asmdef no Inspetor e adicione uma referência às seguintes definições de montagem:

- UnityEngine.TestRunner

- UnityEditor.TestRunner

- Unity.InputSystem

- Unity.InputSystem.TestFramework

- ThirdPersonControllerMain

Clique em Aplicar.

Seu primeiro teste

Seu primeiro teste cobrirá alguns conceitos básicos sobre carregar e mover o personagem principal do pacote Third Person Controller.

Comece configurando o novo projeto com uma cena de ambiente de teste simples e um recurso Prefab de personagem para trabalhar.

Abra a cena chamada Assets/StarterAssets/ThirdPersonController/Scenes/Playground.unity e salve uma cópia dela usando o menu Arquivo > Salvar Como neste novo caminho: Assets/Scenes/SimpleTesting.unity

Se você notar materiais rosa na visualização do jogo, use o Conversor de Pipeline de Renderização para atualizar materiais do Pipeline de Renderização Integrado para o Pipeline de Renderização Universal (URP). Veja este artigo para uma visão geral rápida.

Crie uma nova pasta na sua pasta de Projetos chamada Recursos. Observação: O nome da pasta “Recursos” é importante aqui para permitir que o método Resources.Load() do Unity seja usado.

Arraste e solte o GameObject PlayerArmature na visualização da cena na nova pasta Recursos e escolha criar um Prefab Original quando solicitado. Renomeie o ativo Prefab para Personagem.

Este será o Prefab base do personagem usado em seus testes daqui para frente.

Remova o GameObject PlayerArmature da nova cena SimpleTesting e salve as alterações na cena.

Para a última etapa na configuração inicial do teste, vá para Arquivo > Configurações de Construção e escolha Adicionar Cenas Abertas para adicionar a cena Cenas/SimpleTesting às configurações de construção.

Crie um script de teste em C#

Selecione a pasta Testes na pasta de Projetos. Clique com o botão direito e escolha Criar > Teste > Script de Teste C#.

Nomeie o novo Script como CharacterTests. Abra o script em seu IDE para dar uma olhada mais de perto.

Dois stubs de método são fornecidos com o arquivo de classe inicial, demonstrando algumas noções básicas de teste.

Em seguida, você garantirá que os testes carreguem uma cena de jogo "focada em testes". Esta deve ser uma cena contendo o mínimo necessário para testar o sistema ou componente no qual você está se concentrando.

Atualize a classe CharacterTests para adicionar duas novas usando declarações e implemente a classe InputTestFixture:

using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;

public class CharacterTests : InputTestFixture

Adicione dois campos privados ao topo da classe CharacterTests:

GameObject character = Resources.Load("Character");
Teclado teclado;

O campo de personagem armazenará uma referência ao Prefab do Personagem, carregado da pasta Resources. Teclado manterá uma referência ao dispositivo de entrada do Teclado fornecido pelo InputSystem.

Substitua o método Setup() da classe base InputTestFixture fornecendo o seu próprio na classe CharacterTests:

public override void Setup()
{
SceneManager.LoadScene("Scenes/SimpleTesting");
base.Setup();
teclado = InputSystem.AddDevice();

var mouse = InputSystem.AddDevice();
Press(mouse.rightButton);
Libere(mouse.rightButton);;
}

O método Setup() executa o método Setup() da classe base e, em seguida, configura sua própria classe CharacterTests carregando a cena de teste e inicializando o dispositivo de entrada do teclado.

A entrada do mouse é adicionada puramente para que o Controlador de Terceira Pessoa comece a receber entrada do dispositivo de teclado simulado/virtual. Isso é quase como uma ação de ‘definir foco’.

Para seu primeiro teste, você instanciará o personagem do Prefab e afirmará que não é nulo. Adicione o seguinte método à sua classe de teste:

[Test]
public void TestPlayerInstantiation()
{
GameObject characterInstance = GameObject.Instantiate(character, Vector3.zero, Quaternion.identity);
Assert.That(characterInstance, !Is.Null);
}

Enquanto você está lá, pode querer limpar os métodos de teste do modelo de amostra. Remova os métodos CharacterTestsSimplePasses e CharacterTestsWithEnumeratorPasses.

verificação de teste passada — A marca de verificação verde significa que o teste foi concluído com sucesso

Aprovando seu primeiro teste

Salve o script e volte para a janela Test Runner no Editor. Realce o teste TestPlayerInstantiation e clique em Run Selected.

A marca de verificação verde significa um teste aprovado. Você afirmou que o personagem pode ser carregado dos recursos, instanciado na cena de teste e não é nulo nesse ponto.

Você pode ter notado que a anotação [Teste] foi usada para este teste em vez da anotação [UnityTest]. O atributo UnityTest permite que corrotinas executem testes em vários quadros. Neste caso, você só precisa instanciar o personagem e afirmar que ele foi carregado.

Geralmente, você deve usar o atributo de teste NUnit em vez do atributo UnityTest no modo de edição, a menos que precise fornecer instruções especiais, precise pular um quadro ou esperar um certo período de tempo no modo de jogo.

Teste da movimentação do personagem no modo Play

Testes de movimento de personagem

Em seguida, você usará o UnityTest ao afirmar que manter pressionada a tecla do controlador para frente move o personagem para frente.

Adicione o novo método de teste fornecido abaixo à sua classe CharacterTests.

Dois novos métodos auxiliares de teste apareceram; Press() e Release(). Ambos são fornecidos pela classe base InputTestFixture e ajudam você emular a pressão e liberação do controle do InputSystem.

O método TestPlayerMoves() faz o seguinte:

Instancia uma instância do personagem a partir do Prefab do personagem na localização (X: 0, Y: 0, Z: 0)

Pressiona a tecla de seta para cima no teclado virtual por 1 segundo, depois a solta

Espera mais 1 segundo (para o personagem desacelerar e parar de se mover)

Afirma que o personagem se moveu para uma posição no eixo Z maior que 1,5 unidades.

Salve o arquivo, retorne ao Test Runner e execute o novo teste.

Testando dano de queda

Em seguida, você testará um script Monobehaviour personalizado adicionando um componente simples de Player Health.

Crie um novo script em Assets/StarterAssets/ThirdPersonController/Scripts. Nomeie-o como PlayerHealth.

Abra o script em seu IDE e substitua o conteúdo pelo código fornecido abaixo.

Há muito código novo adicionado aqui. Para resumir, este script determinará se o personagem do jogador está em um estado de queda. Se o chão for atingido uma vez em um estado de queda, a saúde do personagem é reduzida em 10%.

Localize o Prefab do personagem em Assets/Resources. Abra o Prefab e adicione o novo componente de script PlayerHealth.

Em seguida, você usará a cena de teste para afirmar que a saúde do jogador cai após cair de uma borda.

Usando o atributo [UnityTest], você pode escrever um teste de modo Play que testa o dano de queda. Ao cair por mais de 0,2 segundos, o jogador deve sofrer 0,1f de dano (o equivalente a 10% da saúde máxima).

Na cena SimpleTesting, você verá uma escada levando a uma borda. Esta é uma plataforma de teste para gerar o personagem em cima e testar o script PlayerHealth.

Abra CharacterTests.cs novamente e adicione um novo método de teste chamado TestPlayerFallDamage:

[UnityTest]
public IEnumerator TestPlayerFallDamage()
{
// gere o personagem em uma área alta na cena de teste
GameObject characterInstance = GameObject.Instantiate(character, new Vector3(0f, 4f, 17.2f), Quaternion.identity);

// Obtenha uma referência ao componente PlayerHealth e afirme que está atualmente com saúde total (1f)
var characterHealth = characterInstance.GetComponent();
Assert.That(characterHealth.Health, Is.EqualTo(1f));

// Ande pela borda e aguarde a queda
Press(keyboard.upArrowKey);
yield return new WaitForSeconds(0.5f);
Release(keyboard.upArrowKey);
yield return new WaitForSeconds(2f);

// Afirme que 1 ponto de saúde foi perdido devido ao dano da queda
Assert.That(characterHealth.Health, Is.EqualTo(0.9f));
}

Você também precisará adicionar uma referência using ao namespace StarterAssets no topo do arquivo da classe:

using StarterAssets;

O teste acima segue um padrão típico arranjar, agir, afirmar (AAA), comumente encontrado em testes:

A seção Arrange de um método de teste unitário inicializa objetos e define o valor dos dados que são passados para o método em teste.
A seção Act invoca o método em teste com os parâmetros organizados. Neste caso, a invocação do método em teste é tratada por uma interação física quando o jogador atinge o chão após cair.

A seção Assert verifica se a ação do método em teste se comporta como esperado.