Cara Menjalankan Tes Menggunakan Dotnet Test di .NET 10

Halo para pengembang .NET! Siap untuk meningkatkan kemampuan pengujian Anda dengan Microsoft Testing Platform (MTP) dan .NET 10? Jika Anda selama ini menggunakan dotnet test dengan *runner* VSTest tradisional, bersiaplah—MTP hadir untuk membuat pengujian Anda lebih lancar, lebih cepat, dan lebih fleksibel. Dalam panduan percakapan ini, kita akan menjelajahi apa itu MTP, atau MicrosoftTestingPlatform, mengapa ini merupakan peningkatan dari VSTest, dan bagaimana memanfaatkannya dengan dotnet test di .NET 10 untuk membangun pengujian yang tangguh untuk proyek Anda. Saya akan memandu Anda melalui langkah-langkah yang saya ambil untuk bereksperimen dengan *setup* ini, dari proyek MSTest dasar hingga solusi multi-proyek dengan *executable* mandiri. Mari selami dunia MTP, MicrosoftTestingPlatform, .NET 10, dotnet test dan jadikan pengujian lebih mudah dan menyenangkan!

💡

Ingin alat Pengujian API yang hebat yang menghasilkan Dokumentasi API yang indah?

Ingin platform All-in-One yang terintegrasi untuk Tim Pengembang Anda agar dapat bekerja sama dengan produktivitas maksimal?

Apidog memenuhi semua permintaan Anda, dan menggantikan Postman dengan harga yang jauh lebih terjangkau!

button

Mengapa Pengujian Penting dalam Pengembangan .NET

Sebelum kita mulai, mari kita bahas mengapa pengujian adalah hal yang sangat penting. Baik Anda membangun aplikasi kecil atau sistem perusahaan yang besar, pengujian memastikan kode Anda berfungsi seperti yang diharapkan, menangkap *bug* lebih awal, dan menyelamatkan Anda dari sesi *debugging* larut malam. Pengujian unit otomatis, seperti yang akan kita buat dengan MSTest dan MTP, memungkinkan Anda memverifikasi fungsionalitas, meningkatkan kualitas kode, dan membuat *refactoring* menjadi mudah. Dengan peningkatan kinerja .NET 10 dan *framework* pengujian modern MTP, Anda siap untuk menulis pengujian yang cepat, andal, dan mudah diintegrasikan ke dalam *pipeline* CI/CD. Siap melihat caranya? Mari ikuti perjalanan saya!

Apa itu Microsoft Testing Platform (MTP)?

Microsoft Testing Platform (MTP), atau MicrosoftTestingPlatform, adalah *framework* pengujian generasi berikutnya dari Microsoft, yang diperkenalkan untuk menggantikan *runner* VSTest yang sudah tua. Tidak seperti VSTest, yang mengandalkan *adapter* kompleks dan eksekusi berbasis DLL, MTP menawarkan pengalaman yang disederhanakan dan *native* untuk menjalankan pengujian di .NET. Ini dibangun ke dalam .NET 10, membuatnya lebih cepat dan lebih fleksibel, dengan fitur-fitur seperti *test runner* *executable* mandiri dan integrasi yang lebih baik dengan dotnet test. MTP mendukung MSTest, NUnit, dan xUnit, dan dirancang untuk *workflow* modern, termasuk CI/CD dan pengembangan *cross-platform*. Anda bisa menganggapnya sebagai saudara VSTest yang lebih keren dan efisien, dioptimalkan untuk peningkatan kinerja .NET 10.

Langkah 1: Menyiapkan Proyek MSTest Dasar dengan MTP

Mari kita mulai sederhana dengan membuat proyek MSTest dasar untuk melihat MTP beraksi. Begini cara saya memulainya:

Buat Proyek:

Buka terminal Anda dan buat proyek MSTest baru menggunakan .NET CLI:

dotnet new mstest -n MyMtpTests

Ini membuat folder proyek MyMtpTests dengan berkas pengujian *default* (UnitTest1.cs) dan berkas .csproj.

Periksa Berkas Proyek:

MyMtpTests.csproj yang dihasilkan terlihat seperti ini:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
  </ItemGroup>
</Project>

Ini menyiapkan proyek MSTest standar dengan VSTest, menggunakan Coverlet untuk cakupan kode dan Microsoft.NET.Test.Sdk untuk eksekusi pengujian.

Jalankan Pengujian:

Navigasi ke folder proyek:

cd MyMtpTests

Jalankan pengujian *default*:

dotnet test

*Runner* VSTest mengeksekusi pengujian sampel di UnitTest1.cs, dan Anda akan melihat *output* yang mengkonfirmasi pengujian berhasil, beserta statistik cakupan dari Coverlet.

Apa yang Terjadi? Ini adalah *setup* tradisional menggunakan VSTest, tetapi ini adalah dasar yang kuat sebelum kita meningkatkan ke MTP. Proyek ini menjalankan pengujian sebagai DLL, yang baik-baik saja tetapi tidak sefleksibel pendekatan *executable* MTP.

Langkah 2: Berevolusi ke Test Runner Berbasis Executable MTP

Sekarang, mari kita buat segalanya lebih menarik dengan beralih ke *runner* *executable* mandiri MTP, yang memungkinkan Anda menjalankan pengujian tanpa dotnet test. Begini cara saya melakukannya:

Perbarui Berkas Proyek:

Modifikasi MyMtpTests.csproj untuk mengaktifkan MTP dan membuat *executable*:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <!-- Aktifkan runner MTP dan output executable -->
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
    <OutputType>Exe</OutputType>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

Perubahan kunci:

<EnableMSTestRunner>true</EnableMSTestRunner>: Mengaktifkan *test runner* MTP.
<TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>: Memastikan kompatibilitas dengan dotnet test.
<OutputType>Exe</OutputType>: Menghasilkan *executable* mandiri alih-alih DLL.

Bangun Proyek:

Jalankan:

dotnet build

Ini menghasilkan *executable* (misalnya, MyMtpTests.exe) di folder bin/Debug/net8.0.

Jalankan Executable:

Navigasi ke direktori *output*:

cd bin/Debug/net8.0

Jalankan *executable*:
Windows: MyMtpTests.exe
macOS/Linux: ./MyMtpTests
Pengujian berjalan sebagai aplikasi konsol mandiri, tidak perlu dotnet test!

Mengapa Ini Hebat: Pendekatan *executable* sangat cocok untuk *setup* CI/CD khusus atau lingkungan tanpa .NET SDK terinstal. Ini adalah pengubah permainan untuk fleksibilitas, dan MTP membuatnya lebih cepat daripada VSTest dengan mengurangi *overhead*.

Langkah 3: Menjadi Profesional dengan .NET 10 dan Pengujian Multi-Proyek

Untuk melihat MTP dan .NET 10 bersinar dalam skenario dunia nyata, mari kita bangun solusi multi-proyek dengan pustaka kelas dan pengujian. Begini cara saya mengaturnya:

Struktur Proyek Akhir:

MyMtpSolution/
│
├── MyLibrary/
│   ├── Calculator.cs
│   └── MyLibrary.csproj
│
├── MyLibrary.Tests/
│   ├── CalculatorTests.cs
│   └── MyLibrary.Tests.csproj
│
├── MyMtpSolution.sln
└── dotnet.config

1. Buat Solusi:

Mulai segar dengan solusi:

dotnet new sln -n MyMtpSolution

2. Buat Pustaka Kelas:

Tambahkan proyek pustaka kelas:

dotnet new classlib -n MyLibrary

Implementasikan kelas Calculator di MyLibrary/Calculator.cs:

namespace MyLibrary
{
    public class Calculator
    {
        public int Add(int a, int b) => a + b;
        public int Subtract(int a, int b) => a - b;
        public int Multiply(int a, int b) => a * b;
        public int Divide(int a, int b) => 
            b == 0 ? throw new ArgumentException("Tidak dapat membagi dengan nol.") : a / b;
    }
}

3. Buat Proyek Pengujian:

Buat proyek MSTest:

dotnet new mstest -n MyLibrary.Tests

Tambahkan pengujian di MyLibrary.Tests/UnitTest1.cs:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyLibrary;

namespace MyLibrary.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        private Calculator _calculator;

        [TestInitialize]
        public void Setup()
        {
            _calculator = new Calculator();
        }

        [TestMethod]
        public void Add_ReturnsCorrectSum()
        {
            Assert.AreEqual(5, _calculator.Add(2, 3));
        }

        [TestMethod]
        public void Subtract_ReturnsCorrectDifference()
        {
            Assert.AreEqual(1, _calculator.Subtract(3, 2));
        }

        [TestMethod]
        public void Multiply_ReturnsCorrectProduct()
        {
            Assert.AreEqual(6, _calculator.Multiply(2, 3));
        }

        [TestMethod]
        public void Divide_ReturnsCorrectQuotient()
        {
            Assert.AreEqual(2, _calculator.Divide(6, 3));
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentException))]
        public void Divide_ByZero_ThrowsException()
        {
            _calculator.Divide(6, 0);
        }
    }
}

4. Tambahkan Referensi Proyek:

Tautkan proyek pengujian ke pustaka:

dotnet add MyLibrary.Tests reference MyLibrary

5. Tambahkan Proyek ke Solusi:

Sertakan kedua proyek dalam solusi:

dotnet sln MyMtpSolution.sln add MyLibrary/MyLibrary.csproj
dotnet sln MyMtpSolution.sln add MyLibrary.Tests/MyLibrary.Tests.csproj

6. Konfigurasi untuk MTP:

Perbarui MyLibrary.Tests.csproj untuk mengaktifkan MTP:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

Secara opsional, perbarui MyLibrary.csproj untuk konsistensi (meskipun tidak terlalu diperlukan):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

7. Tingkatkan ke .NET 10:

Unduh .NET 10 SDK dari dotnet.microsoft.com (pastikan kompatibel dengan OS Anda—Windows, macOS, atau Linux).

Perbarui kedua berkas .csproj untuk menargetkan .NET 10:

<TargetFramework>net10.0</TargetFramework>

8. Buat Berkas dotnet.config:

Di *root* solusi, buat dotnet.config dengan:

[dotnet.test.runner]
name = "Microsoft.Testing.Platform"

Ini mengaktifkan integrasi *native* MTP dengan dotnet test di .NET 10.

9. Bangun dan Jalankan Pengujian:

Dari *root* solusi:

dotnet test

MTP menjalankan pengujian, memanfaatkan optimasi .NET 10. Anda akan melihat *output* untuk semua pengujian, termasuk lulus/gagal dan statistik cakupan.

Mengapa Ini Hebat: .NET 10 membawa peningkatan kinerja (JIT lebih cepat, manajemen memori lebih baik), dan integrasi *native* MTP menghilangkan jembatan lama VSTest, membuat pengujian lebih cepat dan lebih andal. *Setup* multi-proyek meniru aplikasi dunia nyata, dengan pustaka dan proyek pengujian terpisah.

Bagaimana .NET 10 dan MTP Meningkatkan Pengujian

MTP dan .NET 10 membawa pengujian ke tingkat berikutnya:

Kecepatan: *Runner* *native* MTP dioptimalkan untuk .NET 10, mengurangi waktu *startup* dibandingkan dengan VSTest.
Fleksibilitas: *Executable* mandiri membuat pengujian portabel, ideal untuk CI/CD khusus atau lingkungan *containerized*.
Skalabilitas: Dukungan multi-proyek menangani solusi kompleks, dengan MTP memastikan eksekusi pengujian yang konsisten.
Fitur Modern: Kompilasi AOT dan optimasi memori .NET 10 membuat pengujian berjalan lebih cepat, sementara MTP mendukung fitur canggih seperti eksekusi pengujian paralel dan *reporter* khusus.

Pengguna ramai membicarakan MTP: "Ini seperti VSTest tetapi tanpa beban—lebih cepat dan lebih bersih!" Dengan .NET 10, Anda mendapatkan kinerja mutakhir, dan MTP membuat dotnet test menjadi menyenangkan.

Tips Pemecahan Masalah

Pengujian Tidak Berjalan? Pastikan .NET 10 SDK terinstal dan TargetFramework diatur ke net10.0.
MTP Tidak Diaktifkan? Periksa apakah EnableMSTestRunner dan TestingPlatformDotnetTestSupport ada di .csproj atau dotnet.config.
Cakupan Hilang? Verifikasi coverlet.collector disertakan dan jalankan dotnet test --collect:"XPlat Code Coverage".
Executable Gagal? Pastikan OutputType adalah Exe dan jalankan dotnet build sebelum mengeksekusi .exe.

Kesimpulan

Anda sekarang adalah seorang profesional dalam menggunakan MTP (MicrosoftTestingPlatform), .NET 10, dotnet test untuk membangun *setup* pengujian modern! Dari proyek MSTest dasar hingga solusi multi-proyek dengan *executable* mandiri, Anda telah melihat bagaimana MTP mengungguli VSTest dan bagaimana .NET 10 meningkatkan kinerja. Coba tambahkan lebih banyak pengujian, integrasikan ke dalam *pipeline* CI/CD Anda, atau jelajahi fitur-fitur canggih MTP seperti eksekusi paralel. Punya *setup* pengujian yang keren? Bagikan—mari terus semangat pengujian!

button