Modul ini mengeksplorasi penggunaan GitHub Copilot dan GitHub Copilot Chat untuk membuat pengujian unit. Latihan memberikan pengalaman praktis membuat proyek pengujian unit dan menjalankan pengujian unit di Visual Studio Code.

Di akhir modul ini, Anda dapat:

• Buat pengujian unit menggunakan ekstensi GitHub Copilot dan GitHub Copilot Chat untuk Visual Studio Code.
• Buat pengujian unit yang menargetkan kasus tepi dan kondisi tertentu menggunakan ekstensi GitHub Copilot dan GitHub Copilot Chat untuk Visual Studio Code.
• Gunakan Visual Studio Code, .NET SDK, dan ekstensi C# Dev Kit untuk membuat proyek pengujian dan memverifikasi bahwa pengujian unit Anda berhasil dibangun dan berjalan.

• Langganan aktif untuk GitHub Copilot diperlukan untuk akun GitHub pribadi Anda atau akun GitHub yang dikelola oleh organisasi atau perusahaan.
• Pengalaman menggunakan ekstensi GitHub Copilot dan GitHub Copilot Chat untuk Visual Studio Code untuk menghasilkan saran pelengkapan otomatis dan menjelaskan kode yang ada.
• Satu atau lebih tahun pengalaman pengembangan perangkat lunak direkomendasikan.
• Pengalaman mengembangkan aplikasi C# menggunakan Visual Studio Code dan ekstensi C# Dev Kit direkomendasikan.
• Kesadaran akan kondisi uji coba gratis GitHub Copilot. Jika Anda memilih penawaran uji coba gratis untuk GitHub Copilot, bentuk pembayaran diminta saat mendaftar. Biaya tidak diterapkan hingga uji coba berakhir, kecuali jika Anda membatalkan sebelum berakhirnya periode 30 hari.

• Mempercepat pengembangan aplikasi dengan menggunakan GitHub Copilot
• Dasar-dasar GitHub Copilot - Memahami pemrogram pasangan AI

Pengujian unit adalah aspek penting dari pengembangan perangkat lunak yang memastikan fungsionalitas masing-masing komponen dalam sistem.

Modul ini memperkenalkan cara menghasilkan pengujian unit dengan GitHub Copilot dan GitHub Copilot Chat di Visual Studio Code. Modul ini berfokus pada penggunaan tampilan Obrolan, obrolan sebaris, dan penyelesaian kode untuk membuat pengujian unit untuk kerangka kerja pengujian xUnit. Visual Studio Code dan ekstensi C# Dev Kit digunakan untuk membuat proyek pengujian unit dan mengelola pengujian unit.

Bayangkan Anda adalah pengembang perangkat lunak yang mengerjakan basis kode besar. Tim Anda bertugas memastikan keandalan kode. Anda menentukan bahwa pengujian unit diperlukan untuk sebagian besar basis kode. Namun, membuat pengujian unit secara manual dapat memakan waktu dan rawan kesalahan. Anda memerlukan alat yang membantu Anda mengembangkan pengujian unit dengan cepat dan akurat. Alat ini juga harus membantu mengidentifikasi kasus tepi dan kondisi batas. Anda mendengar bahwa GitHub Copilot dapat mempercepat pengembangan pengujian unit dan membantu mengidentifikasi kasus tepi. Anda menantikan untuk mengembangkan pengujian unit dengan lebih cepat dan akurat menggunakan GitHub Copilot.

Topik yang dibahas dalam modul ini meliputi:

• Membuat pengujian unit di Visual Studio Code menggunakan GitHub Copilot dan GitHub Copilot Chat.
• Membuat pengujian unit khusus untuk kasus tepi dan kondisi batas menggunakan GitHub Copilot Chat.
• Membuat proyek pengujian unit dan mengelola pengujian unit di Visual Studio Code.
• Menyelesaikan tantangan "buat pengujian unit" dan meninjau kemungkinan solusi.

Pada akhir modul ini, Anda dapat menggunakan alat GitHub Copilot dan Visual Studio Code untuk membuat, mengelola, dan menjalankan pengujian unit secara efisien. Menggunakan GitHub Copilot meningkatkan keandalan basis kode Anda dan menghemat waktu pengembangan yang berharga.

Untuk menyelesaikan pelatihan GitHub Copilot ini, Anda harus memiliki langganan aktif untuk GitHub Copilot di akun GitHub pribadi Anda, atau Anda harus ditetapkan ke langganan yang dikelola oleh organisasi atau perusahaan. Untuk menyelesaikan aktivitas modul, Anda harus mengonfigurasi akun Anda untuk mengizinkan saran GitHub Copilot yang cocok dengan kode publik. Jika Anda adalah anggota organisasi di GitHub Enterprise Cloud yang telah diberi kursi GitHub Copilot melalui organisasi Anda, pengaturan untuk saran yang cocok dengan kode publik akan diwarisi dari organisasi atau perusahaan Anda. Jika akun Anda memblokir saran yang cocok dengan kode publik, aktivitas modul tidak akan berfungsi seperti yang diharapkan.

GitHub Copilot Chat dapat digunakan untuk menyarankan pengujian unit berdasarkan kode yang Anda tentukan. Misalnya, jika Anda menentukan tanda tangan dan isi metode, GitHub Copilot Chat dapat menyarankan kasus pengujian yang mencakup parameter input dan nilai output yang diharapkan. Setelah proyek pengujian Anda berisi beberapa kasus pengujian, Anda dapat menggunakan GitHub Copilot untuk menghasilkan saran penyelesaian kode untuk kasus pengujian tambahan. Menggunakan penyelesaian baris kode untuk menghasilkan pengujian unit mengurangi proses berulang dan membantu memastikan bahwa kode Anda diuji secara menyeluruh.

GitHub Copilot Chat menggunakan konteks dan semantik kode Anda untuk menyarankan pernyataan yang memastikan fungsi berfungsi dengan benar. Ini juga membantu Anda menulis kasus pengujian untuk kasus tepi dan kondisi batas yang mungkin sulit diidentifikasi secara manual. Misalnya, GitHub Copilot Chat dapat menyarankan kasus pengujian untuk penanganan kesalahan, nilai null, atau jenis input yang tidak terduga.

Kasus pengujian yang dihasilkan mungkin tidak mencakup semua skenario yang mungkin. Pengujian manual dan tinjauan kode diperlukan untuk memastikan kualitas kode Anda.

Visual Studio Code menyediakan akses mudah ke fitur GitHub Copilot dan GitHub Copilot Chat berikut:

• Penyelesaian baris kode: Gunakan penyelesaian baris kode untuk menulis kode dengan lebih efisien.
• Obrolan sebaris: Mulai percakapan obrolan sebaris langsung dari editor untuk mendapatkan bantuan saat Anda membuat kode.
• Tampilan obrolan: Buka asisten AI di samping yang dapat membantu Anda kapan saja.
• Obrolan Cepat: Ajukan pertanyaan singkat dan kembali ke apa yang Anda lakukan.
• Tindakan cerdas: Jalankan tindakan pintar untuk menyelesaikan tugas tertentu bahkan tanpa harus menulis perintah.

Ekstensi GitHub Copilot mempercepat pengembangan kode dan membuat Anda tetap berada di dalam lingkungan Visual Studio Code.

Untuk membuat dan menjalankan pengujian unit C# di Visual Studio Code, Anda memerlukan sumber daya berikut:

• .NET 8.0 SDK atau yang lebih baru.
• Ekstensi C# Dev Kit untuk Visual Studio Code.
• Paket kerangka kerja pengujian ditambahkan ke proyek Anda.

Ekstensi C# Dev Kit untuk Visual Studio Code menyediakan serangkaian fitur yang kaya untuk membantu Anda membuat dan mengelola pengujian unit untuk proyek C# Anda. Ini mencakup fitur-fitur berikut:

• Test Explorer - Tampilan hierarki untuk memperlihatkan semua kasus pengujian di ruang kerja Anda.
• Eksekusi/Debug kasus pengujian - Fitur untuk menjalankan dan men-debug kasus pengujian.
• Lihat hasil pengujian - Fitur untuk melihat hasil pengujian.
• Perintah pengujian - Perintah untuk menjalankan semua pengujian, menjalankan pengujian yang gagal, dan banyak lagi.
• Pengaturan pengujian - Pengaturan khusus untuk pengujian.
• Paket kerangka kerja pengujian

• xUnit
• NUnit
• MSTest

C# Dev Kit memungkinkan Anda membuat proyek pengujian, menambahkan paket kerangka kerja pengujian, dan mengelola pengujian unit.

Palet Perintah di Visual Studio Code menyediakan cara termudah untuk mengaktifkan kerangka kerja pengujian untuk proyek Anda. Anda dapat membuka Palet Perintah dengan cara berikut:

• Tekan tombol Ctrl + Shift + P (Windows/Linux) atau Cmd + Shift + P (macOS).
• Buka menu Tampilan, lalu pilih Palet Perintah.
• Buka tampilan Penjelajah Solusi, klik kanan folder solusi, lalu pilih Proyek Baru. Opsi ini membuka Palet Perintah dengan perintah .NET:Proyek Baru... yang sudah dipilih.

Bagian berikut menjelaskan cara mengaktifkan kerangka kerja pengujian untuk proyek C# Anda menggunakan Palet Perintah.

Buka Palet Perintah dan pilih .NET:Proyek Baru... lalu pilih Proyek Uji xUnit dan berikan nama dan lokasi untuk proyek baru. Perintah ini membuat proyek dan direktori baru yang menggunakan xUnit sebagai pustaka pengujian dan mengonfigurasi pelari pengujian dengan menambahkan elemen berikut ke file proyek.

• Microsoft.NET.Test.Sdk
• xUnit
• xunit.runner.visualstudio
• coverlet.collector

Dari Terminal, Anda dapat menjalankan perintah berikut:

dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

Buka Palet Perintah dan pilih .NET:Proyek Baru... lalu pilih Proyek Uji NUnit3 dan berikan nama dan lokasi untuk proyek baru. Perintah ini membuat proyek dan direktori baru yang menggunakan NUnit sebagai pustaka pengujian dan mengonfigurasi test runner dengan menambahkan elemen berikut ke file proyek.

• Microsoft.NET.Test.Sdk
• NUnit
• NUnit3TestAdapter

Dari Terminal, jalankan perintah berikut:

dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

Buka Palet Perintah dan pilih .NET:Proyek Baru... lalu pilih Proyek Pengujian MSTest dan berikan nama dan lokasi untuk proyek baru. Perintah ini membuat proyek dan direktori baru yang menggunakan MSTest sebagai pustaka pengujian dan mengonfigurasi pelari pengujian dengan menambahkan elemen berikut ke file proyek.

• Microsoft.NET.Test.Sdk
• MSTest.TestAdapter
• MSTest.TestFramework
• coverlet.collector

Dari Terminal, jalankan perintah berikut:

dotnet add [location of your test csproj file] reference [location of the csproj file for project to be tested]

Kombinasi Visual Studio Code dan GitHub Copilot Chat menyediakan lingkungan yang kuat untuk membuat dan menjalankan pengujian unit untuk proyek C# Anda.

Proses pengujian unit dapat dipecah menjadi tiga tahap:

• Gunakan Visual Studio Code untuk membuat proyek pengujian untuk pengujian unit Anda.
• Gunakan GitHub Copilot Chat untuk mengembangkan kasus pengujian unit untuk proyek C# Anda.
• Gunakan Visual Studio Code dan C# Dev Kit untuk menjalankan dan mengelola pengujian unit Anda.

Anda perlu membuat proyek pengujian yang akan digunakan untuk menyimpan pengujian unit Anda. Anda dapat menggunakan Visual Studio Code untuk menyelesaikan tugas-tugas berikut:

1. Gunakan Palet Perintah untuk membuat proyek pengujian yang menggunakan kerangka kerja pengujian tertentu.
2. Gunakan Terminal terintegrasi untuk menambahkan referensi ke project yang sedang Anda uji.

Proses ini membuat proyek baru dan mengonfigurasi test runner untuk kerangka kerja yang dipilih.

GitHub Copilot Chat dapat digunakan untuk membantu Anda menulis kasus pengujian unit untuk kerangka kerja pengujian Anda. Copilot Chat mengenali kerangka kerja pengujian dan gaya pengkodean Anda dan menghasilkan cuplikan kode yang cocok. Anda dapat menggunakan Copilot Chat untuk menyelesaikan tugas berikut:

• Tulis kasus pengujian unit untuk kerangka kerja pengujian Anda berdasarkan kode yang terbuka di editor atau cuplikan kode yang Anda sorot di editor. Copilot mengidentifikasi kerangka kerja pengujian dan gaya pengkodean Anda dan menghasilkan cuplikan kode yang cocok.
• Identifikasi dan tulis kasus pengujian untuk kasus tepi dan kondisi batas yang mungkin sulit diidentifikasi secara manual. Misalnya, Copilot dapat menyarankan kasus pengujian untuk penanganan kesalahan, nilai null, atau jenis input yang tidak terduga.
• Sarankan pernyataan yang memastikan fungsi berfungsi dengan benar, berdasarkan konteks dan semantik kode. Misalnya, buat pernyataan untuk memastikan bahwa parameter input fungsi valid.

Pertimbangkan skenario berikut saat meminta Copilot Chat untuk membuat kasus pengujian unit:

• Jika satu metode terlihat secara lengkap di editor, Anda dapat meminta Copilot Chat untuk membuat pengujian unit untuk metode tersebut dengan mengetik .Write a unit test for the method in the #editor
• Jika ada beberapa metode yang terlihat atau metode yang dimaksud melampaui yang terlihat di editor, pilih kode yang ingin Anda buat pengujian unitnya, lalu tanyakan kepada Copilot: .#selection write a unit test for this code

Visual Studio Code dan C# Dev Kit menyediakan serangkaian fitur yang kaya untuk membantu Anda menjalankan dan mengelola pengujian unit untuk proyek C# Anda. Anda dapat menjalankan/men-debug kasus pengujian, melihat hasil pengujian, dan mengelola kasus pengujian menggunakan Test Explorer.

Kasus pengujian Jalankan/Debug: C# Dev Kit menghasilkan pintasan (tombol putar hijau) di sisi kiri definisi kelas dan metode. Untuk menjalankan kasus pengujian target, pilih tombol putar hijau. Anda juga dapat mengklik kanan padanya untuk melihat opsi lainnya.

• Test Explorer: Test Explorer adalah tampilan hierarki untuk memperlihatkan semua kasus pengujian di ruang kerja Anda. Anda dapat memilih tombol gelas kimia di bilah Aktivitas sisi kiri Visual Studio Code untuk membukanya. Anda juga dapat menjalankan/men-debug kasus pengujian Anda dan melihat hasil pengujiannya dari sana.
• Lihat hasil pengujian: Setelah menjalankan/men-debug kasus pengujian, status item pengujian terkait diperbarui di dekorasi editor dan Penjelajah Pengujian. Anda dapat memilih tautan dalam pelacakan tumpukan untuk menavigasi ke lokasi sumber.
• Perintah pengujian Visual Studio Code: Ada perintah pengujian (misalnya, Jalankan Semua Pengujian) yang dapat ditemukan dengan mencari Test: di Palet Perintah.
• Pengaturan pengujian Visual Studio Code: Ada pengaturan Visual Studio Code khusus untuk pengujian yang dapat ditemukan dengan mencari Pengujian di editor Pengaturan.

Di bagian ini, Anda mempelajari cara menggunakan GitHub Copilot Chat untuk menghasilkan kasus pengujian unit untuk proyek C# Anda. Anda mempelajari cara membuat proyek pengujian untuk proyek C# Anda, menghasilkan kasus pengujian unit menggunakan Obrolan Copilot, serta menjalankan dan mengelola pengujian unit Anda di Visual Studio Code. Dengan menggabungkan kekuatan Visual Studio Code dan GitHub Copilot Chat, Anda dapat membuat dan menjalankan pengujian unit dengan lebih efisien dan efektif, membantu Anda memastikan kualitas dan keandalan basis kode Anda.

Visual Studio Code dan C# Dev Kit menyediakan serangkaian fitur yang kaya untuk membantu Anda membuat dan mengelola pengujian unit untuk proyek C# Anda. Anda dapat mengaktifkan pengujian untuk proyek Anda, menambahkan paket kerangka kerja pengujian, menjalankan dan mengelola pengujian unit, dan membuat kasus pengujian unit menggunakan C# Dev Kit.

GitHub Copilot dapat membantu Anda membuat pengujian unit untuk kode Anda dengan memberikan saran obrolan sebaris.

Dalam latihan ini, Anda membuat pengujian unit untuk proyek kode dengan menggunakan GitHub Copilot Chat di Visual Studio Code.

Modul ini mencakup aktivitas praktik yang menggunakan GitHub Copilot, GitHub Copilot Chat, dan sampel kode yang disiapkan. Kegiatan dirancang untuk lingkungan yang mencakup sumber daya berikut:

• Kode Visual Studio.
• Ekstensi C# Dev Kit untuk Visual Studio Code
• Ekstensi GitHub Copilot dan GitHub Copilot Chat untuk Visual Studio Code. Akun GitHub dengan langganan aktif untuk GitHub Copilot diperlukan.
• Contoh proyek kode yang dibuat menggunakan C#.

Untuk mempersiapkan latihan dalam modul ini, selesaikan langkah-langkah berikut:

1. Untuk mengunduh file zip yang berisi aplikasi sampel, pilih tautan berikut: SampleApps.

2. Buka zip file unduhan.

Buka zip file di lingkungan pengembangan Anda. Pertimbangkan untuk menggunakan PC Anda sebagai lingkungan pengembangan Anda sehingga Anda memiliki akses ke kode Anda setelah menyelesaikan modul ini. Jika Anda tidak menggunakan PC sebagai lingkungan pengembangan, Anda dapat mengekstrak file di sandbox atau lingkungan yang dihosting.

• Di komputer lokal Anda, navigasikan ke folder unduhan Anda.
• Klik kanan SampleApps.zip, lalu pilih Ekstrak semua.
• Pilih Tampilkan file yang diekstrak setelah selesai, lalu pilih Ekstrak.
• Catat lokasi folder yang diekstrak.

3. Salin folder SampleApps yang diekstrak ke folder Desktop Windows Anda.

Folder SampleApps berisi kumpulan aplikasi sampel, termasuk proyek kode APL2007M4PrimeService yang Anda gunakan dalam latihan ini.

4. Buka folder APL2007M4PrimeService di Visual Studio Code.

5. Perluas folder Numbers, lalu luangkan waktu sebentar untuk meninjau kode dalam file PrimeService.cs.

Penting untuk memahami kode yang Anda uji. Kelas memiliki satu metode publik . Metode ini memeriksa apakah kandidat bilangan bulat yang diberikan adalah bilangan prima (bilangan bulat yang lebih besar dari 1 yang tidak memiliki pembagi positif selain 1 dan dirinya sendiri). Metode ini mengembalikan jika kandidat adalah bilangan prima dan jika tidak. Metode ini mengikuti langkah-langkah berikut untuk menentukan apakah suatu bilangan prima:PrimeServiceIsPrime(int candidate)truefalse

• Jika kurang dari 2, itu bukan bilangan prima, jadi metode mengembalikan .candidatefalse
• Jika 2 atau lebih, ia memeriksa pembagi dari 2 hingga akar kuadrat dari . Alasan untuk hanya memeriksa hingga akar kuadrat adalah bahwa faktor yang lebih besar dari angka tersebut akan menjadi kelipatan dari faktor yang lebih kecil yang telah diperiksa.candidatecandidate
• Jika dapat dibagi rata (dengan sisa 0) dengan salah satu pembagi potensial ini, itu bukan bilangan prima, jadi metode mengembalikan .candidatefalse
• Jika tidak ada pembagi seperti itu yang ditemukan, maka adalah bilangan prima, sehingga metode mengembalikan .candidatetrue

Metode ini menyediakan beberapa opsi untuk pengujian unit.

Anda sekarang siap untuk menyelesaikan latihan.

Proyek pengujian unit biasanya dibuat dalam folder yang terpisah dari proyek yang Anda uji. Pemisahan ini membantu menjaga kode pengujian terpisah dari kode produksi. Dalam latihan ini, Anda membuat proyek pengujian xUnit untuk proyek APL2007M4PrimeService.

Untuk membuat proyek pengujian xUnit baru, selesaikan langkah-langkah berikut:

1. Buka tampilan Penjelajah Solusi di Visual Studio Code.

Tampilan Penjelajah Solusi dapat diakses dari panel Bilah Samping Visual Studio Code. Penjelajah Solusi mirip dengan tampilan Explorer, tetapi dirancang khusus untuk bekerja dengan proyek Visual Studio Code daripada sistem file umum.

2. Dalam tampilan Penjelajah Solusi, klik kanan APL2007M4PrimeService, lalu pilih Proyek Baru.

Jika Anda tidak melihat opsi Proyek Baru, pastikan Anda bekerja dalam tampilan Penjelajah Solusi, bukan tampilan Penjelajah.

3. Saat daftar jenis proyek muncul, pilih Proyek Uji xUnit.

4. Untuk nama proyek, ketik PrimeService.UnitTests lalu tekan Enter.

Nama proyek harus mencerminkan nama kelas yang Anda uji dan harus unik dalam solusi. Dalam hal ini class diberi nama , sehingga proyek pengujian diberi nama .PrimeServicePrimeService.UnitTests

5. Pilih lokasi direktori default.

Anda juga dapat membuat proyek pengujian xUnit menggunakan terminal Visual Studio Code. Buka terminal, navigasikan ke folder Numbers, lalu jalankan perintah berikut:

dotnet new xunit -n PrimeService.UnitTests

6. Pilih Buat Proyek, lalu perluas folder PrimeService.UnitTests.

7. Hapus file UnitTest1.cs yang dibuat dengan proyek PrimeService.UnitTests.

Sebelum membuat pengujian unit baru, Anda perlu menambahkan referensi ke proyek pengujian unit yang menunjuk ke proyek kelas yang ingin Anda uji.

8. Untuk menambahkan referensi ke proyek kode Anda, klik kanan PrimeService.UnitTests, pilih Tambahkan Referensi Proyek, lalu pilih Angka.

9. Untuk membuat kelas untuk pengujian unit Anda, klik kanan PrimeService.UnitTests, pilih File Baru, pilih Class, ketik PrimeServiceTests, lalu tekan Enter.

Visual Studio Code akan membuka file PrimeServiceTests.cs untuk Anda.

10. Luangkan waktu sebentar untuk memeriksa file PrimeServiceTests.cs.

File Anda harus mirip dengan cuplikan kode berikut:

namespace PrimeService.UnitTests;

public class PrimeServiceTests
{

}

11. Untuk membantu menghindari masalah namespace saat Anda mem-build proyek, perbarui file PrimeServiceTests.cs sebagai berikut:

namespace System.Numbers.UnitTests;

public class PrimeServiceTests
{

}

Ruang nama di C# digunakan untuk mengatur kelas dan jenis terkait. Ini adalah cara untuk menghindari tabrakan nama dan membuatnya lebih mudah untuk memahami organisasi kode. Akhiran dalam namespace proyek pengujian adalah konvensi umum untuk menunjukkan bahwa kode di namespace ini menguji kode di namespace System.Numbers. Ini memperjelas ketika melihat struktur proyek kode mana yang merupakan kode produksi dan kode mana yang merupakan kode uji..UnitTests

12. Luangkan waktu sebentar untuk memeriksa file PrimeService.UnitTests.csproj.

File PrimeService.UnitTests.csproj harus menyertakan file yang berisi elemen berikut:

<PackageReference Include="coverlet.collector" Version="6.0.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="xunit" Version="2.5.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />

Referensi paket ini diperlukan untuk menggunakan xUnit sebagai pustaka pengujian dan untuk mengonfigurasi runner pengujian. Anda juga akan melihat elemen berikut dalam file PrimeService.UnitTests.csproj:

<ItemGroup>
    <Using Include="Xunit" />
</ItemGroup>

<ItemGroup>
    <ProjectReference Include="..\Numbers\Numbers.csproj" />
</ItemGroup>

Elemen-elemen ini diperlukan untuk mereferensikan proyek Numbers dan menggunakan kerangka kerja pengujian xUnit.

13. Untuk membangun solusi, tekan Ctrl+Shift+B, lalu pilih dotnet: build.

Anda juga dapat membangun solusi menggunakan perintah .NET CLI (dotnet build) atau dengan mengklik kanan simpul solusi dalam tampilan Penjelajah Solusi dan memilih Build.

Jika Anda melihat kesalahan build, tinjau langkah-langkah dalam latihan ini untuk memastikan bahwa Anda telah mengikuti setiap langkah dengan benar. Anda harus memiliki build yang sukses sebelum melanjutkan.

Anda sekarang siap membuat pengujian unit menggunakan GitHub Copilot Chat.

GitHub Copilot dan GitHub Copilot Chat dapat membantu Anda menghasilkan pengujian unit untuk kode Anda dengan memberikan saran berdasarkan konteks basis kode Anda. Anda dapat menggunakan GitHub Copilot Chat untuk membuat pengujian unit untuk metode atau kelas tertentu dalam kode Anda.

Gunakan langkah-langkah berikut untuk menyelesaikan bagian latihan ini:

1. Dalam tampilan Penjelajah Solusi, di bawah Angka, buka file PrimeService.cs.
2. Pilih metode IsPrime.
3. Buka tampilan Obrolan.
4. Pilih tombol Lampirkan Konteks.

Tombol Lampirkan Konteks (ikon penjepit kertas) digunakan untuk memberi tahu GitHub Copilot tentang konteks yang relevan dalam basis kode Anda. Konteks tambahan membantu GitHub Copilot Chat untuk memberikan saran yang lebih akurat. Dalam hal ini, Anda ingin GitHub Copilot menggunakan file PrimeServiceTests.cs Anda saat mengusulkan pengujian unit.

5. Dalam daftar dropdown Cari lampiran, di bagian yang baru dibuka, pilih PrimeServiceTests.cs.

Menu menurun Cari lampiran menyediakan beberapa opsi default yang dapat Anda pilih. Ini juga mencakup daftar file yang baru dibuka. File PrimeServiceTests.cs harus tercantum di bagian yang baru dibuka.

Opsi Cari lampiran meliputi

6. Pilih tombol Lampirkan Konteks lagi.

7. Dalam kotak teks Cari lampiran, ketik PrimeService.Unit, lalu pilih PrimeService.UnitTests.csproj.

Nota
Anda juga dapat menyeret file dari tampilan Explorer dan meletakkannya ke tampilan Obrolan. Dalam banyak kasus, ini adalah cara yang lebih cepat untuk melampirkan konteks.

8. Perhatikan bahwa tampilan Obrolan diperbarui dengan konteks tambahan.

9. Dalam tampilan Obrolan, pilih /tests tambahkan pengujian unit untuk kode saya.

Opsi /tests tambahkan pengujian unit untuk kode saya digunakan untuk menghasilkan pengujian unit untuk kode yang telah Anda pilih di editor. Dalam hal ini, Anda memilih metode IsPrime di file PrimeService.cs.

10. Luangkan waktu sejenak untuk meninjau saran GitHub Copilot.

Saran GitHub Copilot mencakup dua bagian, "Rencana" dan sampel kode yang berisi pengujian unit. Rencana tersebut menyarankan untuk membuat file PrimeServiceTest.cs baru untuk pengujian unit. Ini juga menyarankan untuk membuat file di folder proyek Numbers.

11. Dalam tampilan Obrolan, pilih Terapkan Pengeditan.

12. Perhatikan bahwa tombol Terapkan Edit menempatkan kode pengujian unit pada tab baru di editor.

Anda dapat menggunakan kode ini untuk memperbarui file PrimeServiceTests.cs di proyek PrimeService.UnitTests Anda.

13. Pada menu File, pilih Simpan Sebagai, lalu navigasikan ke folder PrimeService.UnitTests.

14. Pilih PrimeServiceTests.cs, lalu pilih Simpan.

15. Saat diminta untuk menimpa file yang ada, pilih Ya.

16. Luangkan waktu sebentar untuk meninjau file PrimeServiceTests.cs yang diperbarui.

Kode yang disarankan oleh GitHub Copilot Chat harus menyertakan pengujian untuk bilangan prima dan non-prima tertentu. Kode yang disarankan dapat mencakup pengujian parameter (menggunakan dan atribut) untuk menguji beberapa kumpulan data secara lebih ringkas.[Theory][InlineData]

Cuplikan kode yang disediakan harus mirip dengan cuplikan kode berikut:

using Xunit;

namespace System.Numbers.UnitTests
{
    public class PrimeServiceTests
    {
        private readonly PrimeService _primeService;

        public PrimeServiceTests()
        {
            _primeService = new PrimeService();
        }

        [Fact]
        public void IsPrime_InputIs1_ReturnsFalse()
        {
            var result = _primeService.IsPrime(1);

            Assert.False(result, "1 should not be prime");
        }

        [Fact]
        public void IsPrime_InputIs2_ReturnsTrue()
        {
            var result = _primeService.IsPrime(2);

            Assert.True(result, "2 should be prime");
        }

        [Fact]
        public void IsPrime_InputIs3_ReturnsTrue()
        {
            var result = _primeService.IsPrime(3);

            Assert.True(result, "3 should be prime");
        }

        [Fact]
        public void IsPrime_InputIs4_ReturnsFalse()
        {
            var result = _primeService.IsPrime(4);

            Assert.False(result, "4 should not be prime");
        }

        [Theory]
        [InlineData(5, true)]
        [InlineData(6, false)]
        [InlineData(7, true)]
        [InlineData(8, false)]
        [InlineData(9, false)]
        [InlineData(10, false)]
        public void IsPrime_Values_ReturnExpectedResult(int value, bool expected)
        {
            var result = _primeService.IsPrime(value);

            Assert.Equal(expected, result);
        }
    }
}

Perhatikan bahwa pengujian unit memerlukan instance kelas PrimeService.

private readonly PrimeService _primeService;

public PrimeServiceTests()
{
    _primeService = new PrimeService();
}

17. Bangun kembali solusinya.

Anda akan melihat "panah pengujian" berwarna hijau di sebelah setiap pengujian unit jika build berhasil.

Anda membuat lebih banyak pengujian unit di bagian berikutnya, jadi tidak perlu menjalankan pengujian saat ini.

Namun, ada beberapa cara untuk menjalankan pengujian Anda. Misalnya:

• Anda dapat menjalankan pengujian dari terminal Visual Studio Code dengan menggunakan perintah.dotnet test
• Anda dapat menjalankan pengujian dari tampilan Visual Studio Code Test Explorer.
• Anda dapat menjalankan pengujian dari Palet Perintah Visual Studio Code dengan menggunakan perintah Uji: Jalankan Semua Pengujian.
• Anda dapat menjalankan pengujian dari editor Visual Studio Code dengan memilih opsi Jalankan Pengujian di File Saat Ini dari menu konteks.

Tes yang Anda buat selama bagian latihan ini akan berjalan dengan sukses. "Panah uji" hijau di sebelah pengujian unit menjadi lingkaran hijau dengan tanda centang.

1. Gunakan langkah-langkah berikut untuk menyelesaikan bagian latihan ini:

PrimeService.cs terletak di folder Numbers.

2. Pilih metode IsPrime.

3. Buka sesi obrolan sebaris, lalu masukkan perintah berikut:

Create unit tests for the IsPrime method using the xUnit framework.

4. Luangkan waktu sejenak untuk meninjau saran yang diberikan oleh obrolan sebaris.

using Xunit;

namespace System.Numbers.UnitTests
{
    public class PrimeServiceTests
    {
        private readonly PrimeService _primeService;

        public PrimeServiceTests()
        {
            _primeService = new PrimeService();
        }

        [Fact]
        public void IsPrime_InputIs1_ReturnsFalse()
        {
            var result = _primeService.IsPrime(1);

            Assert.False(result, "1 should not be prime");
        }

        [Fact]
        public void IsPrime_InputIs2_ReturnsTrue()
        {
            var result = _primeService.IsPrime(2);

            Assert.True(result, "2 should be prime");
        }

        [Fact]
        public void IsPrime_InputIs3_ReturnsTrue()
        {
            var result = _primeService.IsPrime(3);

            Assert.True(result, "3 should be prime");
        }

        [Fact]
        public void IsPrime_InputIs4_ReturnsFalse()
        {
            var result = _primeService.IsPrime(4);

            Assert.False(result, "4 should not be prime");
        }

        [Theory]
        [InlineData(5, true)]
        [InlineData(6, false)]
        [InlineData(7, true)]
        [InlineData(8, false)]
        [InlineData(9, false)]
        [InlineData(10, false)]
        public void IsPrime_Values_ReturnExpectedResult(int value, bool expected)
        {
            var result = _primeService.IsPrime(value);

            Assert.Equal(expected, result);
        }
    }
}

5. Perhatikan bahwa tampilan Obrolan dan obrolan sebaris menghasilkan cakupan pengujian yang serupa.

6. Untuk membuang saran obrolan sebaris, pilih Buang, lalu tutup tab file yang dibuat oleh obrolan sebaris.

Perlu diingat bahwa pengujian unit yang disarankan oleh GitHub Copilot selama latihan ini mungkin tidak lengkap. Unit berikutnya memeriksa kasus tepi tambahan yang mungkin Anda pertimbangkan untuk diuji.

Dalam latihan ini, Anda membuat pengujian unit untuk proyek kode dengan menggunakan GitHub Copilot Chat di Visual Studio Code. Anda membuat proyek pengujian xUnit, menambahkan referensi ke proyek yang ingin Anda uji, dan membuat pengujian unit untuk metode di kelas. Anda menggunakan GitHub Copilot Chat untuk menghasilkan pengujian unit dalam tampilan Obrolan dan obrolan sebaris.IsPrimePrimeService

Ekstensi GitHub Copilot dapat membantu Anda membuat pengujian unit untuk kondisi tertentu dalam kode Anda. Misalnya, Anda dapat menggunakan GitHub Copilot Chat untuk menguji perilaku metode saat menerima input tertentu.

Dalam latihan ini, Anda menggunakan ekstensi GitHub Copilot untuk membuat pengujian unit untuk kondisi tertentu.

Anda dapat membuat pengujian unit menggunakan saran pelengkapan otomatis GitHub Copilot. Menggunakan saran pelengkapan otomatis dapat membantu Anda membuat pengujian unit untuk kode dengan cepat.

Di bagian latihan ini, Anda menggunakan GitHub Copilot untuk membuat pengujian unit untuk metode kelas.IsPrimePrimeService

Gunakan langkah-langkah berikut untuk menyelesaikan bagian latihan ini:

1. Temukan folder SampleApps yang berisi aplikasi sampel untuk pelatihan ini.

2. Buka folder proyek APL2007M4PrimeService-UnitTests di Visual Studio Code.

3. Buka file PrimeServiceTests.cs di editor.

4. Hapus semua kode di dalam kelas.PrimeServiceTests

Isi file PrimeServiceTests.cs harus menyerupai cuplikan kode berikut:

namespace System.Numbers.UnitTests;

public class PrimeServiceTests
{
}

5. Simpan file PrimeServiceTests.cs, lalu bangun ulang solusinya.

6. Agar GitHub Copilot menghasilkan penyelesaian sebaris, buat baris kosong di dalam kelas.PrimeServiceTests

Jika Anda menunggu satu atau dua detik, GitHub Copilot menyarankan penyelesaian untuk kelas tersebut.PrimeServiceTests

7. Pilih Terima, dan luangkan waktu sebentar untuk meninjau pengujian unit yang dihasilkan oleh GitHub Copilot.

8. Luangkan waktu sebentar untuk meninjau kumpulan pengujian unit yang dihasilkan GitHub Copilot untuk metode tersebut.IsPrime

Tidak apa-apa jika cakupan tes tidak lengkap. Bagian latihan berikutnya menunjukkan kepada Anda cara menggunakan GitHub Copilot Chat untuk meminta GitHub Copilot menyarankan kasus tepi tambahan yang harus diuji.

# C#
namespace System.Numbers.UnitTests
{
    public class PrimeServiceTests
    {
        private readonly PrimeService _primeService;

        public PrimeServiceTests()
        {
            _primeService = new PrimeService();
        }

        [Fact]
        public void IsPrime_ReturnsFalse_ForNegativeNumbers()
        {
            // Arrange
            int candidate = -5;

            // Act
            bool result = _primeService.IsPrime(candidate);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void IsPrime_ReturnsFalse_ForZero()
        {
            // Arrange
            int candidate = 0;

            // Act
            bool result = _primeService.IsPrime(candidate);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void IsPrime_ReturnsFalse_ForOne()
        {
            // Arrange
            int candidate = 1;

            // Act
            bool result = _primeService.IsPrime(candidate);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void IsPrime_ReturnsTrue_ForPrimeNumbers()
        {
            // Arrange
            int candidate = 7;

            // Act
            bool result = _primeService.IsPrime(candidate);

            // Assert
            Assert.True(result);
        }
    }
}

1. Pilih konten kelas.PrimeServiceTests

2. Buka tampilan Obrolan.

3. Untuk menambahkan file PrimeService.cs ke konteks tampilan Obrolan, seret dan lepas file PrimeService.cs dari tampilan Explorer ke tampilan Obrolan.

4. Masukkan perintah berikut dalam tampilan Obrolan:

@workspace #selection are there any edge cases that should also be tested

Berikut adalah beberapa kasus tepi yang harus diuji untuk metode 

IsPrime

 dalam 

System.Numbers.PrimeService

:

1. **Angka negatif**: Pastikan bahwa angka negatif tidak dianggap sebagai bilangan prima.
2. **Nol dan satu**: Pastikan bahwa 0 dan 1 tidak dianggap sebagai bilangan prima.
3. **Bilangan prima kecil**: Uji bilangan prima kecil seperti 2, 3, 5, dll.
4. **Bilangan non-prima kecil**: Uji bilangan non-prima kecil seperti 4, 6, 8, dll.
5. **Bilangan prima besar**: Uji bilangan prima besar untuk memastikan metode ini dapat menangani skala besar.
6. **Bilangan non-prima besar**: Uji bilangan non-prima besar untuk memastikan metode ini dapat menangani skala besar.

Berikut adalah contoh bagaimana Anda dapat menulis unit test untuk kasus-kasus tepi ini:

using System;
using Xunit;

namespace System.Numbers.Tests
{
    public class PrimeServiceTests
    {
        private readonly PrimeService _primeService;

        public PrimeServiceTests()
        {
            _primeService = new PrimeService();
        }

        [Theory]
        [InlineData(-1)]
        [InlineData(0)]
        [InlineData(1)]
        public void IsPrime_NegativeOrZeroOrOne_ReturnsFalse(int value)
        {
            var result = _primeService.IsPrime(value);
            Assert.False(result, $"{value} seharusnya bukan bilangan prima");
        }

        [Theory]
        [InlineData(2)]
        [InlineData(3)]
        [InlineData(5)]
        [InlineData(7)]
        public void IsPrime_SmallPrimes_ReturnsTrue(int value)
        {
            var result = _primeService.IsPrime(value);
            Assert.True(result, $"{value} seharusnya bilangan prima");
        }

        [Theory]
        [InlineData(4)]
        [InlineData(6)]
        [InlineData(8)]
        [InlineData(9)]
        public void IsPrime_SmallNonPrimes_ReturnsFalse(int value)
        {
            var result = _primeService.IsPrime(value);
            Assert.False(result, $"{value} seharusnya bukan bilangan prima");
        }

        [Theory]
        [InlineData(17)]
        [InlineData(19)]
        [InlineData(23)]
        public void IsPrime_LargePrimes_ReturnsTrue(int value)
        {
            var result = _primeService.IsPrime(value);
            Assert.True(result, $"{value} seharusnya bilangan prima");
        }

        [Theory]
        [InlineData(15)]
        [InlineData(21)]
        [InlineData(25)]
        public void IsPrime_LargeNonPrimes_ReturnsFalse(int value)
        {
            var result = _primeService.IsPrime(value);
            Assert.False(result, $"{value} seharusnya bukan bilangan prima");
        }
    }
}

Tes-tes ini mencakup berbagai kasus tepi dan memastikan bahwa metode IsPrime berfungsi dengan benar untuk berbagai input.

5. Luangkan waktu sejenak untuk meninjau saran yang diberikan oleh GitHub Copilot.

Yes, there are a few edge cases that should also be tested:

1. Large Prime Numbers: Ensure the function can handle large prime numbers.

2. Large Non-Prime Numbers: Ensure the function can handle large non-prime numbers.

3. Even Numbers Greater Than 2: Ensure the function returns false for even numbers greater than 2.

4. Small Prime Numbers: Ensure the function correctly identifies small prime numbers like 2 and 3.

Here are the additional test cases:

[Fact]
public void IsPrime_ReturnsTrue_ForTwo()
{
    // Arrange
    int candidate = 2;

    // Act
    bool result = _primeService.IsPrime(candidate);

    // Assert
    Assert.True(result);
}

[Fact]
public void IsPrime_ReturnsTrue_ForThree()
{
    // Arrange
    int candidate = 3;

    // Act
    bool result = _primeService.IsPrime(candidate);

    // Assert
    Assert.True(result);
}

[Fact]
public void IsPrime_ReturnsFalse_ForEvenNumbersGreaterThanTwo()
{
    // Arrange
    int candidate = 4;

    // Act
    bool result = _primeService.IsPrime(candidate);

    // Assert
    Assert.False(result);
}

[Fact]
public void IsPrime_ReturnsTrue_ForLargePrimeNumber()
{
    // Arrange
    int candidate = 7919;

    // Act
    bool result = _primeService.IsPrime(candidate);

    // Assert
    Assert.True(result);
}

[Fact]
public void IsPrime_ReturnsFalse_ForLargeNonPrimeNumber()
{
    // Arrange
    int candidate = 8000;

    // Act
    bool result = _primeService.IsPrime(candidate);

    // Assert
    Assert.False(result);
}

6. Buat baris kosong setelah metode pengujian terakhir di kelas.PrimeServiceTests
7. Dalam tampilan Obrolan, arahkan mouse ke cuplikan kode, lalu pilih Sisipkan di Kursor.
8. Simpan file PrimeServiceTests.cs, lalu bangun ulang solusinya.
9. Luangkan waktu sebentar untuk meninjau kumpulan pengujian unit yang dihasilkan GitHub Copilot untuk metode tersebut.IsPrime

Seperti biasa, penting untuk meninjau pekerjaan yang diselesaikan oleh GitHub Copilot untuk memastikan bahwa pengujian valid dan mencakup kasus tepi yang ingin Anda uji. Setelah puas dengan pengujian, Anda dapat menjalankannya untuk memverifikasi bahwa pengujiannya lulus.

10. Arahkan penunjuk mouse ke salah satu "panah uji" hijau.

Perhatikan pesan tooltip yang memberi tahu Anda bahwa Anda dapat mengklik untuk menjalankan pengujian, atau klik kanan untuk melihat opsi lainnya.

11. Klik kanan salah satu "panah uji" berwarna hijau.

12. Pilih Ungkapkan di Test Explorer.

Perhatikan bahwa tampilan Test Explorer terbuka. Tampilan Test Explorer dapat digunakan untuk menjalankan dan men-debug pengujian, dan untuk melihat hasil eksekusi pengujian. Untuk membuka tampilan Test Explorer secara manual, pilih Testing dari Bilah Aktivitas di sisi kiri jendela Visual Studio Code. Ikon untuk tampilan Pengujian adalah ikon yang terlihat seperti labu lab.

13. Di bagian atas tampilan Test Explorer, pilih Jalankan Tes.

Setelah beberapa detik, Test Explorer menampilkan hasil uji coba. Anda akan melihat bahwa semua tes lulus. Tanda centang hijau di Test Explorer dan di sebelah kiri pengujian unit di Editor menunjukkan bahwa pengujian lulus.

Dalam latihan ini, Anda menggunakan GitHub Copilot dan GitHub Copilot Chat untuk membuat pengujian unit untuk kondisi tertentu di kelas. Anda menggunakan penyelesaian baris kode untuk menghasilkan pernyataan guna memastikan bahwa parameter input fungsi valid, dan Anda menggunakan tampilan Obrolan untuk meminta GitHub Copilot menyarankan kasus tepi tambahan yang harus diuji. Anda meninjau saran yang diberikan oleh GitHub Copilot dan menjalankan pengujian untuk memverifikasi bahwa saran tersebut lulus. Anda juga mempelajari cara menggunakan Test Explorer di Visual Studio Code untuk menjalankan dan melihat hasil eksekusi pengujian.PrimeService

Dalam modul ini, Anda belajar tentang penggunaan GitHub Copilot Chat dan Visual Studio Code untuk membuat dan mengelola pengujian unit. Konten tersebut membahas bagaimana GitHub Copilot Chat membantu menghasilkan cuplikan kode untuk kasus pengujian, menyarankan kemungkinan input, output, pernyataan, dan mengidentifikasi kasus tepi dan kondisi batas. Anda juga mempelajari bagaimana Visual Studio Code, dengan ekstensi C# Dev Kit, menyediakan serangkaian fitur yang kaya untuk mengelola pengujian unit, termasuk Test Explorer, menjalankan dan men-debug kasus pengujian, melihat hasil pengujian, perintah pengujian, dan pengaturan pengujian. Proses ini melibatkan pembuatan proyek pengujian, menghasilkan kasus pengujian unit menggunakan Obrolan Copilot, serta menjalankan serta mengelola pengujian di Visual Studio Code.

Kesimpulan utama dari modul ini adalah pembuatan dan manajemen pengujian unit yang efisien dan efektif, memastikan kualitas dan keandalan basis kode. Anda mempelajari cara membuat pengujian unit untuk proyek C# menggunakan GitHub Copilot Chat di Visual Studio Code. Latihan ini memandu Anda menyiapkan lingkungan Anda dengan Visual Studio Code, ekstensi C# Dev Kit, dan ekstensi GitHub Copilot. Anda juga mempelajari cara mendownload dan mengekstrak aplikasi sampel, termasuk project kode APL2007M4PrimeService, yang berisi class PrimeService yang memeriksa apakah bilangan bulat yang diberikan adalah bilangan prima. Anda kemudian membuat proyek pengujian xUnit, menambahkan referensi ke kelas PrimeService, dan membuat pengujian unit untuk metode IsPrime menggunakan GitHub Copilot Chat.

Bacaan tambahan:

1. Dokumentasi GitHub Copilot
2. GitHub Copilot di Visual Studio Code
3. GitHub Copilot: Pemrogram pasangan AI Anda
4. Menguji dengan C# Dev Kit