Sdílet prostřednictvím

Kurz: Testování vlastní úlohy

  • Článek

Pomocí funkcí testování jednotek v sadě Visual Studio můžete otestovat vlastní úlohu MSBuild před distribucí, abyste zajistili správnost kódu. Informace o výhodách provádění testů a základních testovacích nástrojů najdete v základních informacích o testech jednotek. V tomto kurzu použijete příklady kódu použité v jiných kurzech vlastních úloh NÁSTROJE MSBuild. Následující projekty použité v těchto kurzech jsou k dispozici na GitHubu a zahrnují testy jednotek a integrace pro vlastní úlohy NÁSTROJE MSBuild:

Test jednotek

Vlastní úloha MSBuild je třída, která dědí z Task (přímo nebo nepřímo, protože ToolTask dědí z Task). Metoda, která provádí akce přidružené k úkolu je Execute(). Tato metoda přebírá některé vstupní hodnoty (parametry) a má výstupní parametry, které můžete použít k otestování platnosti. V tomto případě jsou některé vstupní parametry cestami k souborům, takže tento příklad obsahuje testovací vstupní soubory ve složce s názvem Resources. Tato úloha NÁSTROJE MSBuild také generuje soubory, takže test potvrzuje vygenerované soubory.

Je potřeba modul sestavení, což je třída, která implementuje IBuildEngine. V tomto příkladu je napodobení pomocí Moqu, ale můžete použít i jiné napodobení nástrojů. Tento příklad shromažďuje chyby, ale můžete shromáždit další informace a pak je uplatnit.

Napodobení Engine je potřeba pro všechny testy, takže je zahrnuta jako TestInitialize (provádí se před každým testem a každý test má vlastní buildový modul).

Úplný kód najdete v souboru AppSettingStronglyTypedTest.cs v úložišti ukázek .NET na GitHubu.

  1. Vytvořte úlohu a nastavte parametry jako součást uspořádání testu:

        private Mock<IBuildEngine> buildEngine;
    private List<BuildErrorEventArgs> errors;

     [TestInitialize()]
     public void Startup()
     {
         buildEngine = new Mock<IBuildEngine>();
         errors = new List<BuildErrorEventArgs>();
         buildEngine.Setup(x => x.LogErrorEvent(It.IsAny<BuildErrorEventArgs>())).Callback<BuildErrorEventArgs>(e => errors.Add(e));
     }

  2. Vytvořte napodobení parametru ITaskItem (pomocí Moq) a nasměrujte na soubor, který se má analyzovat. Potom vytvořte AppSettingStronglyTyped vlastní úlohu s jeho parametry. Nakonec nastavte modul sestavení na vlastní úlohu MSBuild:

    //Arrange
var item = new Mock<ITaskItem>();
item.Setup(x => x.GetMetadata("Identity")).Returns($".\\Resources\\complete-prop.setting");

var appSettingStronglyTyped = new AppSettingStronglyTyped { SettingClassName = "MyCompletePropSetting", SettingNamespaceName = "MyNamespace", SettingFiles = new[] { item.Object } };

appSettingStronglyTyped.BuildEngine = buildEngine.Object;

    Pak spusťte kód úkolu, který provede skutečnou akci úkolu:

     //Act
 var success = appSettingStronglyTyped.Execute();

  3. Nakonec otestujte očekávaný výsledek testu:

    //Assert
Assert.IsTrue(success); // The execution was success
Assert.AreEqual(errors.Count, 0); //Not error were found
Assert.AreEqual($"MyCompletePropSetting.generated.cs", appSettingStronglyTyped.ClassNameFile); // The Task expected output
Assert.AreEqual(true, File.Exists(appSettingStronglyTyped.ClassNameFile)); // The file was generated
Assert.IsTrue(File.ReadLines(appSettingStronglyTyped.ClassNameFile).SequenceEqual(File.ReadLines(".\\Resources\\complete-prop-class.txt"))); // Assenting the file content

  4. Ostatní testy se řídí tímto vzorem a rozšiřují všechny možnosti.

Poznámka:

Když se vygenerují soubory, musíte pro každý test použít jiný název souboru, aby nedocházelo ke kolizím. Nezapomeňte odstranit vygenerované soubory jako testovací vyčištění.

Integrační testy

Testy jednotek jsou důležité, ale potřebujete také otestovat vlastní úlohu MSBuild v realistickém kontextu sestavení.

Třída System.Diagnostics.Process poskytuje přístup k místním a vzdáleným procesům a umožňuje spouštět a zastavovat místní systémové procesy. Tento příklad spustí sestavení na testu jednotek pomocí testovacích souborů MSBuild.

  1. Testovací kód musí inicializovat kontext spuštění pro každý test. Věnujte pozornost tomu, aby cesta k dotnet příkazu byla pro vaše prostředí přesná. Tady je úplný příklad.

         public const string MSBUILD = "C:\\Program Files\\dotnet\\dotnet.exe";

     private Process buildProcess;
     private List<string> output;

     [TestInitialize()]
     public void Startup()
     {
         output = new List<string>();
         buildProcess = new Process();
         buildProcess.StartInfo.FileName = MSBUILD;
         buildProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
         buildProcess.StartInfo.CreateNoWindow = true;
         buildProcess.StartInfo.RedirectStandardOutput = true;
     }

  2. Při vyčištění musí test dokončit proces:

        [TestCleanup()]
     public void Cleanup()
     {
         buildProcess.Close();
     }

  3. Teď vytvořte každý test. Každý test bude potřebovat k provedení vlastní definice souboru MSBuild. Například testscript-success.msbuild. Informace o souboru najdete v tématu Kurz: Kréta vlastní úkol.

    <Project Sdk="Microsoft.NET.Sdk">
    <UsingTask TaskName="AppSettingStronglyTyped.AppSettingStronglyTyped" AssemblyFile="..\AppSettingStronglyTyped.dll" />
    <PropertyGroup>
        <TargetFramework>netstandard2.1</TargetFramework>
    </PropertyGroup>

    <PropertyGroup>
        <SettingClass>MySettingSuccess</SettingClass>
        <SettingNamespace>example</SettingNamespace>
    </PropertyGroup>

    <ItemGroup>
        <SettingFiles Include="complete-prop.setting" />
    </ItemGroup>

    <Target Name="generateSettingClass">
        <AppSettingStronglyTyped SettingClassName="$(SettingClass)" SettingNamespaceName="$(SettingNamespace)" SettingFiles="@(SettingFiles)">
            <Output TaskParameter="ClassNameFile" PropertyName="SettingClassFileName" />
        </AppSettingStronglyTyped>
    </Target>
</Project>

  4. Testovací argument poskytuje pokyny k sestavení tohoto souboru MSBuild:

     //Arrange
 buildProcess.StartInfo.Arguments = "build .\\Resources\\testscript-success.msbuild /t:generateSettingClass";

  5. Spusťte a získejte výstup:

    //Act
ExecuteCommandAndCollectResults();

    Kde ExecuteCommandAndCollectResults() je definován jako:

    private void ExecuteCommandAndCollectResults()
{
     buildProcess.Start();
     while (!buildProcess.StandardOutput.EndOfStream)
     {
         output.Add(buildProcess.StandardOutput.ReadLine() ?? string.Empty);
     }
     buildProcess.WaitForExit();
}

  6. Nakonec vyhodnoťte očekávaný výsledek:

    //Assert
Assert.AreEqual(0, buildProcess.ExitCode); //Finished success
Assert.IsTrue(File.Exists(".\\Resources\\MySettingSuccess.generated.cs")); // the expected resource was generated
Assert.IsTrue(File.ReadLines(".\\Resources\\MySettingSuccess.generated.cs").SequenceEqual(File.ReadLines(".\\Resources\\testscript-success-class.txt"))); // asserting the file content

Závěr

Testování jednotek je užitečné, protože můžete testovat a ladit kód, abyste zajistili správnost jednotlivých částí kódu, ale s integračními testy je důležité zajistit, aby se úloha prováděla v reálném kontextu sestavení. V tomto kurzu jste zjistili, jak otestovat vlastní úlohu NÁSTROJE MSBuild.

Další kroky

Vytvořte složitější vlastní úlohu, která vytváří generování kódu rozhraní REST API.

Generování klienta REST API pomocí nástroje MSBuild