Esercizio - Sviluppare unit test usando gli strumenti di GitHub Copilot

20 minuti

GitHub Copilot consente di scrivere unit test per il codice. Esistono diversi modi per usare GitHub Copilot per generare unit test:

Generare test case: è possibile usare GitHub Copilot per generare test case per il codice. Copilot può suggerire casi test in base al codice che è stato scritto. È quindi possibile usare questi casi test per creare unit test per il codice.
Generare metodi di test: Copilot può anche generare metodi di test per il codice. È possibile usare questi metodi di test per creare unit test per il codice.
Generare asserzioni di test: Copilot può suggerire asserzioni che è possibile usare negli unit test. Queste asserzioni consentono di verificare il comportamento del codice.
Generare simulazioni di test: Copilot può generare oggetti fittizi che è possibile usare negli unit test. Questi oggetti fittizi consentono di isolare il codice che si sta testando dalle relative dipendenze.
Generare dati di test: Copilot può generare dati di test che è possibile usare negli unit test. Questi dati test consentono di testare il codice con input diversi.
Generare il codice di installazione dei test: Copilot può generare codice di configurazione per gli unit test. Questo codice consente di configurare l'ambiente di test prima di eseguire test.
Generare codice di disinstallazione di test: Copilot può generare codice di disinstallazione per gli unit test. Questo codice consente di ripulire l'ambiente di test dopo l'esecuzione di test.

La soluzione esistente include un progetto di unit test denominato UnitTests. Questo progetto contiene già unit test che coprono parzialmente le classi di servizio nel progetto ApplicationCore.

In questo esercizio, si userà GitHub Copilot per completare le attività seguenti:

Esaminare l'approccio agli unit test implementati dal progetto UnitTests.
Estendere il progetto UnitTests per iniziare a testare le classi di accesso ai dati nel progetto Library.Infrastructure.

Esaminare l'approccio all’esecuzione di unit test implementato dal progetto UnitTests

La codebase esistente include un progetto UnitTests che implementa la struttura di cartelle seguente:

UnitTests\
- ApplicationCore\
  - LoanService\
    - ExtendLoan.cs
    - ReturnLoan.cs
  - PatronService\
    - RenewMembership.cs
- LoanFactory.cs
- PatronFactory.cs

Questa struttura rispecchia e supporta la parte Services del progetto ApplicationCore.

ApplicationCore\
- Services\
  - LoanService.cs: contiene i metodi ExtendLoan e ReturnLoan.
  - PatronService.cs: contiene il metodo RenewMembership.

In questa sezione dell'esercizio, si userà GitHub Copilot per esaminare l'approccio all’esecuzione di unit test implementato dal progetto UnitTests.

Per completare questa sezione dell'esercizio, seguire questa procedura:

Aprire la vista Chat.
Aggiungere i file seguenti al contesto chat: LoanFactory.cs, PatronFactory.cs, ExtendLoan.cs, ReturnLoan.cs, RenewMembership.cs, LoanService.cs, PatronService.cs.

I file si trovano nelle cartelle tests/UnitTests, tests/UnitTests/ApplicationCore/LoanService, tests/UnitTests/ApplicationCore/PatronServicee src/Library.ApplicationCore/Services.
Immettere il prompt seguente:
```
@workspace Explain the approach to unit testing that's been implemented in this workspace.
```
Questa istruzione richiede a GitHub Copilot di spiegare l'approccio all’esecuzione di unit test nel contesto dell'area di lavoro. Diversi file sono inclusi nell’istruzione per fornire contesto per la risposta.
Esaminare la risposta fornita da GitHub Copilot.

Verrà visualizzata una spiegazione simile alla descrizione seguente:
- Simulazione delle dipendenze: i test usano NSubstitute per creare implementazioni fittizie di interfacce.
- Organizzati test: i test sono organizzati in diversi file in base ai metodi testati. Ad esempio, i metodi ExtendLoan e ReturnLoan vengono testati in file diversi nella cartella LoanService.
- Asserzioni: le asserzioni vengono usate per verificare il risultato previsto di ogni test.
- Scenari di test: i test riguardano vari scenari per ogni metodo, ad esempio la restituzione di stati diversi in base all'input.
- Isolamento: ogni test è isolato dagli altri per evitare effetti collaterali.
- Metodi factory: i metodi factory vengono usati per creare dati test in modo coerente.

Immettere il prompt seguente:

@workspace What are the benefits of this approach to unit testing?

Esaminare la risposta fornita da GitHub Copilot.

Verrà visualizzata una spiegazione che identifica un elenco di vantaggi simile a quello seguente:
- Isolamento delle dipendenze: l'uso di simulazioni isola l'unità di lavoro dalle relative dipendenze.
- Ripetibilità e coerenza: i metodi factory offrono un modo coerente per creare dati di test.
- Leggibilità e manutenibilità: metodi di test descrittivi e disposizione chiara dei passaggi di test migliorano la leggibilità dei test.
- Copertura completa: l’esecuzione di test su vari scenari garantisce che il codice sia affidabile e gestisca diversi casi perimetrali.
- Separazione dei problemi: la separazione della creazione di dati test dalla logica di test stessa mantiene i test puliti e incentrati sul comportamento testato.
- Feedback immediato: l'esecuzione di unit test fornisce un feedback immediato sulla correttezza del codice.
Aggiungere i file seguenti al contesto chat: ExtendLoan.cs, ReturnLoan.cs, RenewMembership.cs, LoanFactory.cs, PatronFactory.cs, LoanService.cs, PatronService.cs.
Immettere il prompt seguente:
```
@workspace How can I extend the `UnitTests` project to begin testing methods in the `Library.Infrastructure` project? Provide a process overview.
```
Questa istruzione richiede a GitHub Copilot di fornire una panoramica del processo per estendere il progetto UnitTests per iniziare a testare metodi nel progetto Library.Infrastructure. Diversi file sono inclusi nell’istruzione per fornire contesto per la risposta.

Esaminare la risposta fornita da GitHub Copilot.

Verrà visualizzata una spiegazione simile alla descrizione seguente:

1. Add Project Reference:

  - Open the `UnitTests.csproj` file located at `tests/UnitTests/UnitTests.csproj`.
  - Add a reference to the `Library.Infrastructure` project.

2. Identify methods to test:

  - Identify the methods in the `Library.Infrastructure` project that need to be tested. For example, if you want to test the `LoanService` class, identify the methods in the `LoanService` class that need to be tested.

3. Create Test Classes:

  - Create new test classes in the `tests/UnitTests` directory to test the methods in the `Library.Infrastructure` project. For example, if you want to test `LoanService`, create a file named `LoanServiceTests.cs`.

4. Write Unit Tests:

  - In the newly created test classes, write unit tests for the methods in the `Library.Infrastructure` project. Use the xUnit framework for writing tests and NSubstitute for mocking dependencies.

5. Run Tests:

  - Use Visual Studio Code's integrated terminal or the Test Explorer to run the tests.
  - Ensure that the tests are discovered and executed correctly.

Estendere il progetto UnitTests per iniziare a testare le classi di accesso ai dati

In questa sezione dell'esercizio, si userà GitHub Copilot per creare unit test per il progetto Library.Infrastructure.

Il progetto Library.Infrastructure contiene classi di accesso ai dati che interagiscono con il file system per caricare e salvare i dati. Il progetto include le classi seguenti:

JsonData: classe che carica e salva i dati JSON.
JsonLoanRepository: classe che implementa l'interfaccia ILoanRepository e usa la classe JsonData per caricare e salvare dati loan.
JsonPatronRepository: classe che implementa l'interfaccia IPatronRepository e usa la classe JsonData per caricare e salvare dati patron.

Si inizierà scrivendo unit test per la classe JsonLoanRepository.

Per completare questa sezione dell'esercizio, seguire questa procedura:

Aggiungere i file seguenti al contesto chat: UnitTests.csproj.
Immettere l’istruzione seguente nella vista Chat:
```
@workspace Explain how to add a reference to the Library.Infrastructure project inside `UnitTests.csproj`.
```
Questo prompt chiede a GitHub Copilot di spiegare come aggiungere un riferimento al progetto Library.Infrastructure all'interno del file UnitTests.csproj.

Usare la risposta di GitHub Copilot per aggiornare il file UnitTests.csproj.

Il file UnitTests.csproj aggiornato dovrebbe essere simile al codice XML seguente:

<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="NSubstitute" Version="5.1.0" />
    <PackageReference Include="xunit" Version="2.5.3" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Xunit" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\Library.ApplicationCore\Library.ApplicationCore.csproj" />
    <ProjectReference Include="..\..\src\Library.Infrastructure\Library.Infrastructure.csproj" />
  </ItemGroup>
</Project>

Aprire il file JsonLoanRepository.cs.

JsonLoanRepository.cs si trova nella cartella src/Library.Infrastructure/Data/.

Esaminare il file JsonLoanRepository.cs.

using Library.ApplicationCore;
using Library.ApplicationCore.Entities;

namespace Library.Infrastructure.Data;

public class JsonLoanRepository : ILoanRepository
{
    private readonly JsonData _jsonData;

    public JsonLoanRepository(JsonData jsonData)
    {
        _jsonData = jsonData;
    }

    public async Task<Loan?> GetLoan(int id)
    {
        await _jsonData.EnsureDataLoaded();

        foreach (Loan loan in _jsonData.Loans!)
        {
            if (loan.Id == id)
            {
                Loan populated = _jsonData.GetPopulatedLoan(loan);
                return populated;
            }
        }
        return null;
    }

    public async Task UpdateLoan(Loan loan)
    {
        Loan? existingLoan = null;
        foreach (Loan l in _jsonData.Loans!)
        {
            if (l.Id == loan.Id)
            {
                existingLoan = l;
                break;
            }
        }

        if (existingLoan != null)
        {
            existingLoan.BookItemId = loan.BookItemId;
            existingLoan.PatronId = loan.PatronId;
            existingLoan.LoanDate = loan.LoanDate;
            existingLoan.DueDate = loan.DueDate;
            existingLoan.ReturnDate = loan.ReturnDate;

            await _jsonData.SaveLoans(_jsonData.Loans!);

            await _jsonData.LoadData();
        }
    }
}

Notare i dettagli seguenti sulla classe JsonLoanRepository:
- La classe JsonLoanRepository contiene due metodi: GetLoan e UpdateLoan.
- La classe JsonLoanRepository usa un oggetto JsonData per caricare e salvare dati loan.
Si inizierà scrivendo unit test per il metodo GetLoan.
Creare la struttura di cartelle seguente nel progetto UnitTests.
- Infrastructure\
  - JsonLoanRepository\
Questa struttura di cartelle rispecchia l'approccio usato per gli unit test Library.ApplicationCore.
Creare un file di classe denominato GetLoan nella cartella JsonLoanRepository.
Tenere in considerazione i requisiti del campo e del costruttore di classe per gli unit test GetLoan.

Quando viene chiamato, il metodo JsonLoanRepository.GetLoan riceve un parametro ID loan. Il metodo usa _jsonData.EnsureDataLoaded per ottenere i dati JSON più recenti e _jsonData.Loans per cercare un loan corrispondente. Se il metodo trova un ID loan corrispondente, restituisce un oggetto loan popolato (populated). Se il metodo non riesce a trovare un ID loan corrispondente, restituisce null.

Per gli unit test GetLoan:
- È possibile usare un oggetto repository di loan fittizio (_mockLoanRepository) per testare il caso in cui un ID corrispondente viene trovato. Caricare la simulazione con l'ID che si vuole trovare. La classe ReturnLoanTest illustra come simulare l'interfaccia ILoanRepository e creare un'istanza di un oggetto repository di loan fittizio.
- È possibile usare un oggetto repository di loan non fittizio (_jsonLoanRepository) per testare il caso in cui non viene trovato alcun ID corrispondente. È sufficiente specificare un ID loan che si è certi non sia presente nel file (qualsiasi elemento superiore a 100 dovrebbe andar bene).
- È necessario un oggetto JsonData per creare un oggetto JsonLoanRepository non fittizio. Poiché il progetto UnitTests non ha accesso all'oggetto JsonData creato dal progetto ConsoleApp, è necessario crearne uno usando l'interfaccia IConfiguration.
Aggiungere i file seguenti al contesto chat: JsonLoanRepository.cs, ReturnLoan.cs, LoanService.cs, LoanFactory.cs, JsonData.cs.

Immettere il prompt seguente:

@workspace Create fields and a class constructor for the `GetLoan.cs` file. The class will be used to create unit tests for the GetLoan method in the `JsonLoanRepository.cs` file. Create the following private readonly fields: `_mockLoanRepository`, `_jsonLoanRepository`, `_configuration`, and `_jsonData`. Instantiate the fields in the `GetLoanTest` constructor. Use `ConfigurationBuilder` to create a `_configuration` object that can be used to instantiate the JsonData object.

Questo prompt chiede a GitHub Copilot di suggerire campi e un costruttore di classe.

Esaminare la risposta fornita da GitHub Copilot.

Verrà visualizzato un suggerimento di codice simile al frammento di codice seguente:

using NSubstitute;
using Library.ApplicationCore;
using Library.ApplicationCore.Entities;
using Library.ApplicationCore.Interfaces;
using Library.Infrastructure.Data;
using Microsoft.Extensions.Configuration;

namespace UnitTests.Infrastructure.JsonLoanRepository;

public class GetLoanTest
{
    private readonly ILoanRepository _mockLoanRepository;
    private readonly JsonLoanRepository _jsonLoanRepository;
    private readonly IConfiguration _configuration;
    private readonly JsonData _jsonData;

    public GetLoanTest()
    {
        _mockLoanRepository = Substitute.For<ILoanRepository>();
        _configuration = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json")
            .Build();
        _jsonData = new JsonData(_configuration);
        _jsonLoanRepository = new JsonLoanRepository(_jsonData);
    }

    // Add test methods here
}

Usare il suggerimento di codice fornito da GitHub Copilot per aggiornare GetLoan.cs.
Notare i problemi seguenti:
- Esiste un conflitto tra lo spazio dei nomi e l'uso di JsonLoanRepository nel codice. È necessario aggiornare lo spazio dei nomi in GetLoans.cs in modo che segua il modello usato nei file ReturnLoan.cs e RenewMembership.cs.
- Se ILoanRepository non viene riconosciuto nel codice, potrebbe essere necessario aggiungere una direttiva using per Library.ApplicationCore all'inizio del file.
- Se non è stata creata correttamente un'istanza per l'oggetto _configuration, potrebbe essere necessario aggiornare la riga di codice contenente ConfigurationBuilder. È possibile semplificare il codice per usare _configuration = new ConfigurationBuilder().Build();.
- Se un using Library.ApplicationCore.Interfaces è suggerito da GitHub Copilot, è possibile eliminarlo dall'inizio del file.

Aggiornare il file GetLoan.cs in modo che corrisponda al frammento di codice seguente:

using NSubstitute;
using Library.ApplicationCore;
using Library.ApplicationCore.Entities;
using Library.Infrastructure.Data;
using Microsoft.Extensions.Configuration;

namespace UnitTests.Infrastructure.JsonLoanRepositoryTests;

public class GetLoanTest
{
    private readonly ILoanRepository _mockLoanRepository;
    private readonly JsonLoanRepository _jsonLoanRepository;
    private readonly IConfiguration _configuration;
    private readonly JsonData _jsonData;

    public GetLoanTest()
    {
        _mockLoanRepository = Substitute.For<ILoanRepository>();
        _configuration = new ConfigurationBuilder().Build();
        _jsonData = new JsonData(_configuration);
        _jsonLoanRepository = new JsonLoanRepository(_jsonData);
    }

}

Aggiungere i file seguenti al contesto chat: JsonLoanRepository.cs, ReturnLoan.cs, LoanService.cs, LoanFactory.cs, JsonData.cs. Loans.json.
Selezionare il contenuto del file GetLoan.cs e quindi immettere l’istruzione seguente nella vista Chat:
```
@workspace Update the selection to include a unit test for the `JsonLoanRepository.GetLoan` method. The unit test should test the case where a loan ID is found in the data. Use `_mockLoanRepository` to arrange the expected return loan. Use `_jsonLoanRepository` to return an actual loan. Asserts should verify that the return loan ID matches the expected loan ID. Use a loan ID that exists in the `Loans.json` file.
```
Questa istruzione richiede a GitHub Copilot di suggerire un unit test per il metodo JsonLoanRepository.GetLoan. L’unit test deve testare il caso in cui un ID loan viene trovato tra i dati. Il test deve usare _mockLoanRepository per predisporre il loan restituito previsto, _jsonLoanRepository per restituire un prestito effettivo, e verificare che l'ID loan restituito corrisponda all'ID prestito previsto. L'ID loan deve esistere nel file Loans.json.

Esaminare la risposta fornita da GitHub Copilot.

Verrà visualizzato un suggerimento di codice simile al frammento di codice seguente:

using NSubstitute;
using Library.ApplicationCore;
using Library.ApplicationCore.Entities;
using Library.Infrastructure.Data;
using Microsoft.Extensions.Configuration;
using Xunit;

namespace UnitTests.Infrastructure.JsonLoanRepositoryTests;

public class GetLoanTest
{
    private readonly ILoanRepository _mockLoanRepository;
    private readonly JsonLoanRepository _jsonLoanRepository;
    private readonly IConfiguration _configuration;
    private readonly JsonData _jsonData;

    public GetLoanTest()
    {
        _mockLoanRepository = Substitute.For<ILoanRepository>();
        _configuration = new ConfigurationBuilder().Build();
        _jsonData = new JsonData(_configuration);
        _jsonLoanRepository = new JsonLoanRepository(_jsonData);
    }

    [Fact(DisplayName = "JsonLoanRepository.GetLoan: Returns loan when loan ID is found")]
    public async Task GetLoan_ReturnsLoanWhenLoanIdIsFound()
    {
        // Arrange
        var loanId = 1; // Use a loan ID that exists in the Loans.json file
        var expectedLoan = new Loan { Id = loanId, BookItemId = 101, PatronId = 202, LoanDate = DateTime.Now, DueDate = DateTime.Now.AddDays(14) };
        _mockLoanRepository.GetLoan(loanId).Returns(expectedLoan);
        await _jsonData.EnsureDataLoaded(); // Ensure data is loaded

        // Act
        var actualLoan = await _jsonLoanRepository.GetLoan(loanId);

        // Assert
        Assert.NotNull(actualLoan);
        Assert.Equal(expectedLoan.Id, actualLoan?.Id);
    }
}

Usare il suggerimento di codice fornito da GitHub Copilot per aggiornare GetLoan.cs.

Il metodo JsonLoanRepository.GetLoan chiama _jsonData.EnsureDataLoaded per assicurarsi che i dati JSON vengano caricati. È possibile eliminare la riga di codice che chiama _jsonData.EnsureDataLoaded nel metodo di test, se inclusa.

Se la classe Loan non viene riconosciuta nel codice, assicurarsi di disporre di un'istruzione using Library.ApplicationCore.Entities nella parte superiore del file GetLoan.cs. La classe Loan si trova nello spazio dei nomi Library.ApplicationCore.Entities.
Compilare la soluzione AccelerateDevGitHubCopilot per assicurarsi che non siano presenti errori.
Usare la funzionalità di completamento automatico di GitHub Copilot per creare un test per il caso in cui l'ID loan non viene trovato.

Creare una riga vuota dopo il metodo GetLoan_ReturnsLoanWhenLoanIdIsFound.

Accettare i suggerimenti di completamento automatico per creare un nuovo metodo di test.

Esaminare la risposta fornita da GitHub Copilot.

Probabilmente, la funzionalità di completamento automatico di GitHub Copilot simulerà un loan previsto anche se non necessario. È possibile eliminare il codice che simula un loan previsto, ma è necessario un ID loan che non esiste nel file Loans.json.

Verrà visualizzato un suggerimento di codice simile a uno dei frammenti di codice seguenti:

[Fact(DisplayName = "JsonLoanRepository.GetLoan: Returns null when loan ID is not found")]
public async Task GetLoan_ReturnsNullWhenLoanIdIsNotFound()
{
    // Arrange
    var loanId = 999; // Use a loan ID that does not exist in the Loans.json file
    var expectedLoan = new Loan { Id = loanId, BookItemId = 101, PatronId = 202, LoanDate = DateTime.Now, DueDate = DateTime.Now.AddDays(14) };
    _mockLoanRepository.GetLoan(loanId).Returns(expectedLoan);

    // Act
    var actualLoan = await _jsonLoanRepository.GetLoan(loanId);

    // Assert
    Assert.Null(actualLoan);
}

Accettare il suggerimento di completamento automatico che assegna un valore loanId non incluso nel set di dati.

Se nessuno dei suggerimenti assegna loanId numeri che non sono presenti nel set di dati, è possibile usare i tasti di scelta rapida CTRL+INVIO per elencare altri suggerimenti.
Si noti che gli unit test richiedono l'accesso ai file di dati JSON.

Il metodo JsonLoanRepository.GetLoan usa un oggetto JsonData per caricare e salvare i dati loan.

I file di dati JSON si trovano nella cartella Library.Console\Json. È necessario aggiornare il file UnitTests.csproj in modo da includere questi file nel progetto di test.

Aggiungere il frammento XML seguente al file UnitTests.csproj:

<ItemGroup>
    <None Include="..\..\src\Library.Console\Json\**\*">
        <Link>Json\%(RecursiveDir)%(FileName)%(Extension)</Link>
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

In questo modo, i file di dati JSON vengono copiati nella directory di output all’esecuzione dei test.

Eseguire il test di quanto fatto finora

Esistono diversi metodi per eseguire gli unit test per la classe JsonLoanRepository. È possibile usare Esplora test di Visual Studio Code, il terminale integrato o il comando dotnet test.

Per completare questa sezione dell'esercizio, seguire questa procedura:

Assicurarsi di avere aperto il file GetLoans.cs nell'editor.
Compilare la soluzione e assicurarsi che non siano presenti errori.

Fare clic con il pulsante destro del mouse su AccelerateDevGitHubCopilot e quindi scegliere Compila.
Notare il "pulsante di riproduzione verde" a sinistra dei metodi di test.
Aprire la visualizzazione Esplora test di Visual Studio Code.

Per aprire la visualizzazione Esplora test, selezionare l'icona a forma di ampolla sulla barra attività sul lato sinistro. Esplora test è contrassegnato come "Testing" nell'interfaccia utente.

Esplora test è una visualizzazione albero che mostra tutti i casi test nell'area di lavoro. È possibile eseguire/eseguire il debug dei casi test e visualizzare i risultati test usando Esplora test.
Espandere UnitTests e i nodi sottostanti per individuare GetLoanTest.
Eseguire il JsonLoanRepository.GetLoan: Restituisce un loan nel caso test in cui viene trovato l'ID loan.
Notare i risultati del test nella visualizzazione Esplora test e nell'Editor.

Verrà visualizzato un segno di spunta verde che indica che il test è stato superato.
Usare l'editor per eseguire JsonLoanRepository.GetLoan: Restituisce un loan nel caso test in cui non viene trovato l'ID loan.
Notare i risultati del test nella visualizzazione Esplora test e nell'Editor.

Per eseguire il test dall'Editor, selezionare il pulsante di riproduzione verde a sinistra del metodo di test.
Assicurarsi che JsonLoanRepository.GetLoan: Restituisca un loan quando il caso test in cui non viene trovato l'ID loan è superato.

Verrà visualizzato un segno di spunta verde a sinistra di entrambi i test.

Commenti e suggerimenti

Questa pagina è stata utile?