Partager via

Simuler un client dans les tests

  • Article

Remarque

Ceci n’est pas la dernière version de cet article. Pour la version actuelle, consultez la version .NET 9 de cet article.

Avertissement

Cette version d’ASP.NET Core n’est plus prise en charge. Pour plus d’informations, consultez la stratégie de support .NET et .NET Core. Pour la version actuelle, consultez la version .NET 9 de cet article.

Important

Ces informations portent sur la préversion du produit, qui est susceptible d’être en grande partie modifié avant sa commercialisation. Microsoft n’offre aucune garantie, expresse ou implicite, concernant les informations fournies ici.

Pour la version actuelle, consultez la version .NET 9 de cet article.

Par : James Newton-King

Les tests sont un aspect important de la création de logiciels stables et maintenables. Une partie des tests d’écriture de haute qualité consiste à supprimer les dépendances externes. Cet article décrit l’utilisation de clients gRPC fictifs dans les tests pour supprimer les appels gRPC vers des serveurs externes.

Exemple d’application client testable

Pour illustrer les tests d’application client, consultez le type suivant dans l’exemple d’application.

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)

Le Worker est un BackgroundService qui effectue des appels à un serveur gRPC.

public class Worker : BackgroundService
{
    private readonly Tester.TesterClient _client;
    private readonly IGreetRepository _greetRepository;

    public Worker(Tester.TesterClient client, IGreetRepository greetRepository)
    {
        _client = client;
        _greetRepository = greetRepository;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var count = 0;
        while (!stoppingToken.IsCancellationRequested)
        {
            count++;

            var reply = await _client.SayHelloUnaryAsync(
                new HelloRequest { Name = $"Worker {count}" });

            _greetRepository.SaveGreeting(reply.Message);

            await Task.Delay(1000, stoppingToken);
        }
    }
}

Le type précédent :

  • Suit le Principe des dépendances explicites.
  • TesterClient est généré automatiquement par le package d’outils Grpc.Tools basé sur le fichier test.proto, pendant le processus de génération.
  • Attend l’injection de dépendance pour fournir une instance de TesterClient et de IGreetRepository. L’application est configurée pour utiliser la fabrique de client gRPC pour créer TesterClient.
  • Peut être testé avec un service IGreetRepository fictif et le client TesterClient au moyen d’une infrastructure d’objets fictifs, telle que Moq. Un objet fictif est un objet fabriqué avec un ensemble prédéterminé de comportements de propriété et de méthode utilisés pour les tests. Pour plus d’informations, consultez Tests d’intégration dans ASP.NET Core.

Pour plus d’informations sur les ressources C# générées automatiquement par Grpc.Tools, consultez Services gRPC avec C# : ressources C# générées.

Simuler un client gRPC

Les clients gRPC sont des types de client concrets générés à partir de fichiers .proto. Le client gRPC concret a des méthodes qui sont traduites pour le service gRPC dans le fichier .proto. Par exemple, un service appelé Greeter génère un type GreeterClient avec des méthodes pour appeler le service.

Une infrastructure de simulation peut simuler un type de client gRPC. Lorsqu’un client fictif est passé au type, le test utilise la méthode fictive au lieu d’envoyer un appel gRPC à un serveur.

[Fact]
public async Task Greeting_Success_RepositoryCalled()
{
    // Arrange
    var mockRepository = new Mock<IGreetRepository>();

    var mockCall = CallHelpers.CreateAsyncUnaryCall(new HelloReply { Message = "Test" });
    var mockClient = new Mock<Tester.TesterClient>();
    mockClient
        .Setup(m => m.SayHelloUnaryAsync(
            It.IsAny<HelloRequest>(), null, null, CancellationToken.None))
        .Returns(mockCall);

    var worker = new Worker(mockClient.Object, mockRepository.Object);

    // Act
    await worker.StartAsync(CancellationToken.None);

    // Assert
    mockRepository.Verify(v => v.SaveGreeting("Test"));
}

Le test unitaire précédent :

  • Simule IGreetRepository et TesterClient à l’aide de Moq.
  • Démarre le travail.
  • Vérifie si SaveGreeting est appelé avec le message d’accueil renvoyé par le TesterClient simulé.

Ressources supplémentaires