Test d'application Web d'apprentissage Golang

Avec le développement rapide de la technologie Internet, l'importance des applications Web devient de plus en plus importante. Afin de garantir la qualité et la fiabilité des applications Web, les tests sont inévitables. Dans l'apprentissage Golang, les tests d'applications Web sont également une partie sur laquelle il faut se concentrer et étudier. Cet article décrira les tests d'applications Web dans l'apprentissage Golang, y compris les tests unitaires, les tests d'intégration et les tests de bout en bout.

1. Tests unitaires

Les tests unitaires font référence au test de la plus petite unité testable du programme pour garantir que chaque unité du programme peut fonctionner correctement. . Dans les applications Web, les tests unitaires ciblent généralement les unités logiques telles que le routage et les processeurs.

Ce qui suit est un exemple simple montrant comment utiliser le package testing du langage Go pour les tests unitaires :

package main

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

func TestHelloHandler(t *testing.T) {
    req, err := http.NewRequest("GET", "/hello", nil)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(helloHandler)

    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    if rr.Body.String() != "Hello, World!" {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), "Hello, World!")
    }
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, World!"))
}

Ci-dessus, nous avons créé le type de structure testing.T du testing package TestHelloHandler fonction de test. Cette fonction lancera une requête GET vers la route "/hello" de l'application et vérifiera si le code d'état de la réponse et le corps de la réponse sont corrects.

2. Tests d'intégration

Les tests d'intégration font référence à l'intégration des dépendances entre les tests unitaires pour garantir que l'ensemble du programme peut fonctionner normalement. Dans les applications Web, les tests d'intégration testent généralement les instructions SQL, les procédures stockées, etc.

Ce qui suit est un exemple simple montrant comment utiliser les packages net/http et base de données/sql du langage Go pour les tests d'intégration :

package main

import (
    "database/sql"
    "log"
    "net/http"
    "net/http/httptest"
    "os"
    "testing"

    _ "github.com/lib/pq"
)

var (
    db *sql.DB
    ts *httptest.Server
)

func TestMain(m *testing.M) {
    db, _ = sql.Open("postgres", "user=postgres password=postgres host=localhost port=5432 dbname=test sslmode=disable")
    defer db.Close()

    if err := db.Ping(); err != nil {
        log.Fatalf("Could not connect to database: %v", err)
    }
    log.Println("Database connected")

    ts = httptest.NewServer(http.HandlerFunc(helloHandler))
    defer ts.Close()

    code := m.Run()

    os.Exit(code)
}

func TestDatabase(t *testing.T) {
    if err := db.Ping(); err != nil {
        t.Errorf("failed to ping database: %v", err)
    }
}

func TestHelloHandler(t *testing.T) {
    resp, err := http.Get(ts.URL + "/hello")
    if err != nil {
        t.Errorf("failed to send GET request to server: %v", err)
    }

    if resp.StatusCode != http.StatusOK {
        t.Fatalf("expected status code %d but got %d", http.StatusOK, resp.StatusCode)
    }

    if resp.Header.Get("Content-Type") != "text/plain; charset=utf-8" {
        t.Errorf("unexpected response content type")
    }
}

Ci-dessus, nous utilisons la base de données du langage Go/Le sql package connecté et testé la connexion à la base de données PostgreSQL ; en même temps, nous avons également utilisé le package net/http pour simuler le serveur Web et envoyer une requête GET, et testé si la réponse à la requête était correcte. Avant de tester la fonction, nous avons initialisé la base de données et exécuté le serveur de test à l'aide de la fonction TestMain.

3. Tests de bout en bout

Les tests de bout en bout font référence au test de l'ensemble de l'application, en simulant les opérations de l'utilisateur pour garantir que le le programme peut fonctionner comme les utilisateurs l'attendent. Fonctionne comme ça. Dans les applications Web, les tests de bout en bout testent généralement l'interface et les interactions de l'application via des outils automatisés.

Ce qui suit est un exemple simple montrant comment utiliser le package sélénium du langage Go et le pilote Chrome pour des tests de bout en bout :

package main

import (
    "testing"

    "github.com/tebeka/selenium"
)

func TestWebInterface(t *testing.T) {
    caps := selenium.Capabilities{"browserName": "chrome"}
    wd, err := selenium.NewRemote(caps, "")
    if err != nil {
        t.Fatalf("failed to create WebDriver: %v", err)
    }
    defer wd.Quit()

    if err := wd.Get("http://localhost:8080"); err != nil {
        t.Errorf("failed to visit homepage: %v", err)
    }

    elem, err := wd.FindElement(selenium.ByCSSSelector, "h1")
    if err != nil {
        t.Errorf("failed to find header element: %v", err)
    }

    txt, err := elem.Text()
    if err != nil {
        t.Errorf("failed to get header text: %v", err)
    }

    if txt != "Welcome to my website!" {
        t.Errorf("unexpected header text")
    }
}

Ci-dessus, nous utilisons le sélénium package du langage Go A simulé l'interface Web avec le pilote Chrome, testé l'interface et l'interaction de l'application et vérifié si l'élément h1 de la page répondait aux exigences.

Résumé

Les tests unitaires, les tests d'intégration et les tests de bout en bout sont tous indispensables lors du test d'applications Web. Parmi eux, les tests unitaires sont principalement utilisés pour tester la plus petite unité logique du programme ; les tests d'intégration sont utilisés pour tester les dépendances et le fonctionnement global du programme et les tests de bout en bout sont utilisés pour tester l'interface utilisateur et l'interaction de ; la demande. Les trois méthodes de test ci-dessus peuvent être implémentées à l’aide du package de test du langage Go.

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!