Condividi tramite

Scrittura ed esecuzione di test - MRTK2

  • Articolo

Per garantire che MRTK sia affidabile, MRTK dispone di un set di test per garantire che le modifiche al codice non regresse il comportamento esistente. Avere una buona copertura di test in una grande codebase come MRTK è fondamentale per la stabilità e la fiducia quando si apportano modifiche.

MRTK usa Unity Test Runner che usa un'integrazione unity di NUnit. Questa guida fornisce un punto di partenza su come aggiungere test a MRTK. Non verrà spiegato il test di Unity Runner e NUnit , che può essere cercato nei collegamenti forniti.

Prima di inviare una richiesta pull, assicurarsi di:

  1. Eseguire i test in locale in modo che le modifiche non regresseno il comportamento esistente (il completamento delle richieste di archiviazione non sarà consentito se i test hanno esito negativo).

  2. Se si corregge un bug, scrivere un test per testare la correzione e assicurarsi che le modifiche del codice future non lo interromperanno di nuovo.

  3. Se si scrive una funzionalità, scrivere nuovi test per impedire le modifiche imminenti del codice che causano l'interruzione di questa funzionalità.

Attualmente i test playmode sono destinati a essere eseguiti in Unity 2018.4 e potrebbero non riuscire in altre versioni di Unity

Esecuzione di test

Editor Unity

Il test di Unity Test Runner è disponibile in> WindowGeneral>Test Runner e mostrerà tutti i test di modalità di riproduzione e modifica di MRTK disponibili.

Riga di comando

I test possono essere eseguiti anche da uno script di PowerShell che si trova in Scripts\test\run_playmode_tests.ps1. In questo modo verranno eseguiti i test playmode esattamente come vengono eseguiti in github/CI (vedere di seguito) e i risultati della stampa. Ecco alcuni esempi di come eseguire lo script

Eseguire i test nel progetto che si trova in H:\mrtk.dev, con Unity 2018.4 (ad esempio Unity 2018.4.26f1)

.\run_playmode_tests.ps1 H:\mrtk.dev -unityExePath "C:\Program Files\Unity\Hub\Editor\2018.4.26f1\Editor\Unity.exe"

Eseguire i test nel progetto situato in H:\mrtk.dev, con Unity 2018.4, i risultati dell'output in C:\playmode_test_out

.\run_playmode_tests.ps1 H:\mrtk.dev -unityExePath "C:\Program Files\Unity\Hub\Editor\2018.4.26f1\Editor\Unity.exe" -outFolder "C:\playmode_test_out\"

È anche possibile eseguire più volte i test playmode tramite lo run_repeat_tests.ps1 script. Tutti i parametri usati in run_playmode_tests.ps1 possono essere usati.

.\run_repeat_tests.ps1 -Times 5

Convalida delle richieste pull

IL CI di MRTK creerà MRTK in tutte le configurazioni ed eseguirà tutti i test in modalità modifica e riproduzione. L'attivazione dell'integrazione continua può essere attivata pubblicando un commento sulla RICHIESTA di /azp run mrtk_pr github se l'utente dispone di diritti sufficienti. Le esecuzioni ci possono essere visualizzate nella scheda "controlli" della richiesta di richiesta.

Solo dopo che tutti i test sono stati superati correttamente, la richiesta di richiesta può essere unita a main.

Test di stress/test bulk

A volte i test avranno esito negativo solo occasionalmente, che possono essere frustranti per il debug.

Per eseguire più test in locale, modificare gli script di test in base agli script di test. Lo script python seguente dovrebbe rendere questo scenario più pratico.

Prerequisito per l'esecuzione dello script Python è installato Python 3.X.

Per un singolo test che deve essere eseguito più volte:

[UnityTest]
public IEnumerator MyTest() {...}

Eseguire il codice seguente da una riga di comando (è consigliato PowerShell )

cd scripts\tests
# Repeat the test 5 times. Default is 100
python .\generate_repeat_tests.py -n 5 -t MyTest

Copiare e incollare l'output nel file di test. Lo script seguente è per l'esecuzione di più test in sequenza:

cd scripts\tests
# Repeat the test 5 times. Default is 100
python .\generate_repeat_tests.py -n 5 -t MyTest MySecondTest

Il nuovo file di test dovrebbe ora contenere

[UnityTest]
public IEnumerator A1MyTest0(){ yield return MyTest();}
[UnityTest]
public IEnumerator A2MyTest0(){ yield return MyTest();}
[UnityTest]
public IEnumerator A3MyTest0(){ yield return MyTest();}
[UnityTest]
public IEnumerator A4MyTest0(){ yield return MyTest();}
[UnityTest]
public IEnumerator MyTest() {...}

Aprire il test runner e osservare i nuovi test che ora possono essere chiamati ripetutamente.

Scrittura di test

Esistono due tipi di test che possono essere aggiunti per il nuovo codice

  • Test in modalità riproduzione
  • Modifica test in modalità

Test in modalità riproduzione

I test della modalità di riproduzione MRTK hanno la possibilità di testare il modo in cui la nuova funzionalità risponde a origini di input diverse, ad esempio mani o occhi.

I nuovi test della modalità di riproduzione possono ereditare BasePlayModeTests o lo scheletro seguente può essere usato.

Per creare un nuovo test della modalità di riproduzione:

  • Passare a Asset > MRTK > Test > PlayModeTests
  • Fare clic con il pulsante destro del mouse su Crea > script di test > C#
  • Sostituire il modello predefinito con lo scheletro seguente
#if !WINDOWS_UWP
// When the .NET scripting backend is enabled and C# projects are built
// The assembly that this file is part of is still built for the player,
// even though the assembly itself is marked as a test assembly (this is not
// expected because test assemblies should not be included in player builds).
// Because the .NET backend is deprecated in 2018 and removed in 2019 and this
// issue will likely persist for 2018, this issue is worked around by wrapping all
// play mode tests in this check.

using Microsoft.MixedReality.Toolkit.Input;
using Microsoft.MixedReality.Toolkit.Utilities;
using NUnit.Framework;
using System;
using System.Collections;
using System.Linq;
using UnityEngine;
using UnityEngine.TestTools;

namespace Microsoft.MixedReality.Toolkit.Tests
{
    class ExamplePlayModeTests
    {
        // This method is called once before we enter play mode and execute any of the tests
        // do any kind of setup here that can't be done in playmode
        public void Setup()
        {
            // eg installing unity packages is only possible in edit mode
            // so if a test requires TextMeshPro we will need to check for the package before entering play mode
            PlayModeTestUtilities.InstallTextMeshProEssentials();
        }

        // Do common setup for each of your tests here - this will be called for each individual test after entering playmode
        // Note that this uses UnitySetUp instead of [SetUp] because the init function needs to await a frame passing
        // to ensure that the MRTK system has had the chance to fully set up before the test runs.
        [UnitySetUp]
        public IEnumerator Init()
        {
            // in most play mode test cases you would want to at least create an MRTK GameObject using the default profile
            TestUtilities.InitializeMixedRealityToolkit(true);
            yield return null;
        }

        // Destroy the scene - this method is called after each test listed below has completed
        // Note that this uses UnityTearDown instead of [TearDown] because the init function needs to await a frame passing
        // to ensure that the MRTK system has fully torn down before the next test setup->run cycle starts.
        [UnityTearDown]
        public IEnumerator TearDown()
        {
            PlayModeTestUtilities.TearDown();
            yield return null;
        }

        #region Tests

        /// <summary>
        /// Skeleton for a new MRTK play mode test.
        /// </summary>
        [UnityTest]
        public IEnumerator TestMyFeature()
        {
            // ----------------------------------------------------------
            // EXAMPLE PLAY MODE TEST METHODS
            // ----------------------------------------------------------
            // Getting the input system
            // var inputSystem = PlayModeTestUtilities.GetInputSystem();

            // Creating a new test hand for input
            // var rightHand = new TestHand(Handedness.Right);
            // yield return rightHand.Show(new Vector3(0, 0, 0.5f));

            // Moving the new test hand
            // We are doing a yield return here because moving the hand to a new position
            // requires multiple frames to complete the action.
            // yield return rightHand.MoveTo(new Vector3(0, 0, 2.0f));

            // Getting a specific pointer from the hand
            // var linePointer = PointerUtils.GetPointer<LinePointer>(Handedness.Right);
            // Assert.IsNotNull(linePointer);
            // ---------------------------------------------------------

            // Your new test here
            yield return null;
        }
        #endregion
    }
}
#endif

Modifica test in modalità

I test della modalità di modifica vengono eseguiti nella modalità di modifica di Unity e possono essere aggiunti nella cartella MrTK>Test>EditModeTests nel repository di Realtà mista Toolkit. Per creare un nuovo test, è possibile usare il modello seguente:

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using NUnit.Framework;

namespace Microsoft.MixedReality.Toolkit.Tests
{
    class EditModeExampleTest
    {
        [Test]
        /// the name of this method will be used as test name in the unity test runner
        public void TestEditModeExampleFeature()
        {

        }
    }
}

Convenzioni di denominazione dei test

I test devono essere in genere denominati in base alla classe che stanno testando o allo scenario di test. Ad esempio, data una classe da testare:

namespace Microsoft.MixedReality.Toolkit.Input
{
    class InterestingInputClass
    {
    }
}

Valutare la denominazione del test

namespace Microsoft.MixedReality.Toolkit.Tests.Input
{
    class InterestingInputClassTest
    {
    }
}

È consigliabile inserire il test in una gerarchia di cartelle simile al file non di test corrispondente. Ad esempio:

Non-Test: Assets/MRTK/Core/Utilities/InterestingUtilityClass.cs
Test: Assets/MRTK/Tests/EditModeTests/Core/Utilities/InterestingUtilityClassTest.cs

Si tratta di garantire che esista un modo chiaro per trovare la classe di test corrispondente di ogni classe, se esiste una classe di test di questo tipo.

Il posizionamento dei test basati su scenari è meno definito: se il test esegue il sistema di input complessivo, ad esempio, è consigliabile inserirlo in una cartella "InputSystem" nella cartella di test in modalità di modifica o riproduzione corrispondente.

Icone dello script di test

Quando si aggiunge un nuovo test, modificare lo script per avere l'icona MRTK corretta. C'è uno strumento MRTK facile da eseguire:

  1. Passare alla voce di menu Realtà mista Toolkit.
  2. Fare clic su Utilità, quindi aggiornare, quindi icone.
  3. Fare clic su Test e l'aggiornamento verrà eseguito automaticamente, aggiornando gli script di test mancanti delle icone.

Metodi di utilità MRTK

Questa sezione mostra alcuni frammenti di codice/metodi comunemente usati durante la scrittura di test per MRTK.

Esistono due classi di utilità che consentono di configurare MRTK e testare le interazioni con i componenti in MRTK

TestUtilities fornisce i metodi seguenti per configurare la scena MRTK e GameObjects:

/// creates the mrtk GameObject and sets the default profile if passed param is true
TestUtilities.InitializeMixedRealityToolkit()

/// creates an empty scene prior to adding the mrtk GameObject to it
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();

/// sets the initial playspace transform and camera position
TestUtilities.InitializePlayspace();

/// destroys previously created mrtk GameObject and playspace
TestUtilities.ShutdownMixedRealityToolkit();

Per ulteriori metodi di queste classi util, vedere la documentazione API di TestUtilities e PlayModeTestUtilities per ulteriori metodi, mentre vengono estesi regolarmente mentre i nuovi test vengono aggiunti a MRTK.