Comment tester unitairement Go WebSocket ?

Les tests unitaires Go WebSocket peuvent vérifier l'exactitude et la robustesse du serveur WebSocket. Installez les frameworks de test Ginkgo et Gomega. Créez et démarrez un serveur WebSocket. Écriture de tests unitaires : Établissement d'une connexion WebSocket. Envoyez et recevez des messages. Vérifiez la réponse. Exécutez des tests pour vérifier la fonctionnalité du serveur.

Go WebSocket Unit Testing Guide

WebSocket est un protocole réseau qui établit une connexion bidirectionnelle et persistante entre un client et un serveur. Dans Go, [gorilla/websocket](https://godoc.org/github.com/gorilla/websocket) est une bibliothèque populaire pour créer et gérer des connexions WebSocket. Les tests unitaires sont essentiels lors de l'écriture d'un serveur WebSocket car ils vérifient l'exactitude et la robustesse du code. Cet article fournira un guide étape par étape pour les tests unitaires Go WebSocket à l'aide de Ginkgo et Gomega, avec des exemples pratiques.

Étape 1 : Installez le framework de test

Utilisez les modules Go pour gérer les dépendances, installez Ginkgo et Gomega avec la commande suivante :

go get -u github.com/onsi/ginkgo/v2
go get -u github.com/onsi/gomega

Étape 2 : Créez un serveur WebSocket

Créez un nouveau module Go et écrivez Un simple serveur WebSocket, par exemple :

package main

import (
    "github.com/gorilla/websocket"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        conn, err := websocket.Upgrade(w, r, nil, 1024, 1024)
        if err != nil {
            log.Println(err)
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            return
        }
        log.Printf("WebSocket connection established")

        // Handle incoming messages and send responses...
    })

    log.Println("Listening on port 8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Println(err)
    }
}

Étape 3 : Écrire des tests unitaires

Utiliser le framework Ginkgo et Gomega pour écrire des tests unitaires, par exemple :

package main_test

import (
    "bytes"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gorilla/websocket"
    "github.com/onsi/ginkgo/v2"
    "github.com/onsi/gomega"
)

var _ = ginkgo.Describe("WebSocket Server", func() {        
    var (
        ts         *httptest.Server
        clientConn *websocket.Conn
    )
    
    ginkgo.BeforeEach(func() {
        ts = httptest.NewServer(http.HandlerFunc(wsHandler))
        var err error    
        clientConn, _, err = websocket.DefaultDialer.Dial(ts.URL, nil)
        gomega.Expect(err).To(gomega.BeNil())
    })
    
    ginkgo.AfterEach(func() {
        ts.Close()
        clientConn.Close()
    })
    
    ginkgo.It("should establish a WebSocket connection", func() {
        gomega.Expect(clientConn).NotTo(gomega.BeNil())
    })
    
    ginkgo.It("should send and receive messages", func() {
        // Send a message to the server
        err := clientConn.WriteMessage(websocket.TextMessage, []byte("Hello WebSocket!"))
        gomega.Expect(err).To(gomega.BeNil())

        // Read the response from the server
        _, msg, err := clientConn.ReadMessage()
        gomega.Expect(err).To(gomega.BeNil())

        // Verify the response 
        gomega.Expect(string(msg)).To(gomega.Equal("Hello Client!"))
    })
})

Cas pratique

Cet exemple montre comment utiliser Ginkgo et Gomega teste les fonctionnalités de base d'un serveur WebSocket pour établir une connexion et envoyer/recevoir des messages. Vous pouvez étendre ces tests pour vérifier d'autres cas d'utilisation, tels que l'authentification, les limites de connexion ou la gestion des erreurs.

Remarque :

• Assurez-vous de démarrer le serveur WebSocket avant d'exécuter les tests.
• Ajustez l'URL et le port WebSocket pour qu'ils correspondent aux paramètres réels du serveur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!