Skriva och köra tester – MRTK2

  • Artikel

För att säkerställa att MRTK är tillförlitligt har MRTK en uppsättning tester för att säkerställa att ändringar i koden inte regredieras befintligt beteende. Att ha bra testtäckning i en stor kodbas som MRTK är avgörande för stabilitet och förtroende när du gör ändringar.

MRTK använder Unity Test Runner som använder en Unity-integrering av NUnit. Den här guiden ger en startpunkt för hur du lägger till tester i MRTK. Det kommer inte att förklara Unity Test Runner och NUnit som kan letas upp i länkarna.

Innan du skickar en pull-begäran ska du se till att:

  1. Kör testerna lokalt så att dina ändringar inte regresserar befintligt beteende (slutförande av pull-begärandena tillåts inte om några tester misslyckas).

  2. Om du åtgärdar en bugg skriver du ett test för att testa korrigeringen och ser till att framtida kodändringar inte bryter den igen.

  3. Om du skriver en funktion skriver du nya tester för att förhindra kommande kodändringar som bryter mot den här funktionen.

För närvarande är playmode-tester avsedda att köras i Unity 2018.4 och kan misslyckas i andra versioner av Unity

Köra tester

Unity-redigeraren

Unity Test Runner finns under Window>General>Test Runner och visar alla tillgängliga TESTER av MRTK-uppspelnings- och redigeringsläge.

Kommandorad

Tester kan också köras av ett PowerShell-skript som finns på Scripts\test\run_playmode_tests.ps1. Då körs playmode-testerna precis som de körs på github/CI (se nedan) och skriver ut resultat. Här följer några exempel på hur du kör skriptet

Kör testerna på projektet som finns på H:\mrtk.dev med Unity 2018.4 (till exempel Unity 2018.4.26f1)

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

Kör testerna på projektet som finns i H:\mrtk.dev, med Unity 2018.4, utdataresultat till 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\"

Det går också att köra playmode-testerna flera gånger via skriptet run_repeat_tests.ps1 . Alla parametrar som används i run_playmode_tests.ps1 kan användas.

.\run_repeat_tests.ps1 -Times 5

Validering av pull-begäran

MRTK:s CI skapar MRTK i alla konfigurationer och kör alla tester för redigerings- och uppspelningsläge. CI kan utlösas genom att publicera en kommentar på github PR /azp run mrtk_pr om användaren har tillräckliga rättigheter. CI-körningar kan visas på fliken "kontroller" i pull-begäran.

Först när alla tester har godkänts kan pr-begäran slås samman till huvudservern.

Stresstester/masstester

Ibland misslyckas tester bara ibland, vilket kan vara frustrerande att felsöka.

Om du vill ha flera testkörningar lokalt ändrar du enligt testskripten. Följande Python-skript bör göra det här scenariot enklare.

Förutsättningen för att köra Python-skriptet är att Python 3.X är installerat.

För ett enskilt test som måste köras flera gånger:

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

Kör följande från en kommandorad (PowerShell rekommenderas)

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

Kopiera och klistra in utdata i testfilen. Följande skript används för att köra flera tester i följd:

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

Den nya testfilen bör nu innehålla

[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() {...}

Öppna testkörare och observera de nya testerna som nu kan anropas upprepade gånger.

Skriva tester

Det finns två typer av tester som kan läggas till för ny kod

  • Test av uppspelningsläge
  • Redigera lägestester

Test av uppspelningsläge

MRTK-spellägestester har möjlighet att testa hur din nya funktion svarar på olika indatakällor, till exempel händer eller ögon.

Nya spellägestester kan ärva BasePlayModeTests eller så kan stommen nedan användas.

Så här skapar du ett nytt test för uppspelningsläge:

  • Gå till Tillgångar > MRTK-tester >> PlayModeTests
  • Högerklicka, Skapa > testskript för C#-testning >
  • Ersätt standardmallen med stommen nedan
#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

Redigera lägestester

Redigeringslägestester körs i Unitys redigeringsläge och kan läggas till under mappen MRTK-tester>>EditModeTests i Mixed Reality Toolkit-lagringsplatsen. Om du vill skapa ett nytt test kan du använda följande mall:

// 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()
        {

        }
    }
}

Testa namngivningskonventioner

Tester bör vanligtvis namnges baserat på vilken klass de testar, eller det scenario som de testar. Till exempel, givet en klass som ska testas:

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

Överväg att namnge testet

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

Överväg att placera testet i en mapphierarki som liknar motsvarande icke-testfil. Exempel:

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

Det här är för att säkerställa att det finns ett tydligt sätt att hitta varje klasss motsvarande testklass, om det finns en sådan testklass.

Placeringen av scenariobaserade tester är mindre definierad – om testet använder det övergripande indatasystemet kan du till exempel överväga att placera det i en "InputSystem"-mapp i motsvarande redigeringsläge eller testmapp för uppspelningsläge.

Testskriptikoner

När du lägger till ett nytt test ändrar du skriptet så att det har rätt MRTK-ikon. Det finns ett enkelt MRTK-verktyg för att göra det:

  1. Gå till menyalternativet Mixed Reality Toolkit.
  2. Klicka på Verktyg, sedan Uppdatera och sedan Ikoner.
  3. Klicka på Tester så körs uppdateringsappen automatiskt och uppdaterar eventuella testskript som saknar ikoner.

MRTK-verktygsmetoder

I det här avsnittet visas några av de kodfragment/metoder som används ofta när du skriver tester för MRTK.

Det finns två verktygsklasser som hjälper dig att konfigurera MRTK och testa interaktioner med komponenter i MRTK

TestUtilities tillhandahåller följande metoder för att konfigurera MRTK-scenen och 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();

Se API-dokumenten TestUtilities för och PlayModeTestUtilities för ytterligare metoder för dessa util-klasser eftersom de utökas regelbundet medan nya tester läggs till i MRTK.