Praktische Anwendung: API-Tests mit Beego

In den letzten Jahren ist die Entwicklung und Prüfung von APIs (Application Programming Interface) aufgrund der Entwicklung der Internet-Technologie zu einem wichtigen Bestandteil von Internetunternehmen geworden. Aufgrund des einfachen API-Testprozesses, der hohen Effizienz und der hohen Code-Wiederverwendungsrate beginnen immer mehr Internetunternehmen, automatisierte Tests zum Testen ihrer API-Schnittstellen einzusetzen. In diesem Artikel wird detailliert beschrieben, wie Sie das Beego-Framework für API-Tests verwenden.

1. Einführung in das Beego-Framework

Beego ist ein Web-Framework, das auf der Go-Sprache basiert. Aufgrund seiner Effizienz, Einfachheit und leicht zu erlernenden Eigenschaften wird es von immer mehr Entwicklern verwendet. Darüber hinaus bietet Beego auch eine Fülle von Tools und Plug-Ins, darunter ORM, Websocket, Redis, CORS, Swagger und andere Tools, die die Entwicklungseffizienz erheblich verbessern können.

2. Entwicklungstools

Bevor Sie mit der Entwicklung beginnen, müssen Sie zunächst die erforderlichen Entwicklungstools vorbereiten. Die in diesem Artikel verwendete Entwicklungsumgebung ist wie folgt:

1. Betriebssystem: Windows 10

2.Go-Version: go1.11.4 Windows/AMD64

3. GoConvey

5. Browser: Chrome

6. Code-Editor: Sublime Text 3

3. Installation und Konfiguration

Zuerst müssen Sie die Go-Sprachentwicklung installieren Umfeld. Laden Sie das entsprechende Installationspaket von der offiziellen Website herunter (https://golang.org/dl/). Doppelklicken Sie nach Abschluss des Downloads, um das Installationspaket auszuführen und die Installation abzuschließen.

2. Installieren Sie Beego

Nach der Installation der Go-Sprache müssen Sie das Beego-Framework installieren. Beego kann über den folgenden Befehl installiert werden:

go get -u github.com/astaxie/beego

Dieser Befehl lädt das Beego-Framework in den GOPATH-Pfad herunter.

3. Installieren Sie GoConvey

GoConvey ist ein Unit-Test-Framework für die Go-Sprache, das alle Testfälle im Projekt erkennen und diese Testfälle automatisch ausführen kann. Die Methode zur Installation von GoConvey ist wie folgt:

go get github.com/smartystreets/goconvey

4. MySQL installieren

In diesem Artikel verwenden wir die MySQL-Datenbank. Bitte besuchen Sie zum Herunterladen und Installieren die offizielle MySQL-Website: https://dev.mysql.com/downloads/mysql/

Bei der Installation von MySQL wird empfohlen, die integrierte MySQL Workbench zu installieren.

4. Erstellen Sie ein Beego-Projekt

Es gibt viele Möglichkeiten, ein Beego-Projekt zu erstellen. Sie können die Befehlszeile oder das von Beego bereitgestellte Tool verwenden. In diesem Artikel verwenden wir die Befehlszeile, um ein Projekt namens „MyAPI“ zu erstellen. Geben Sie in der Befehlszeile den folgenden Befehl ein:

bee new MyAPI

Anschließend wird im aktuellen Verzeichnis ein Beego-Projekt mit dem Namen „MyAPI“ erstellt.

Als nächstes müssen wir die zuvor installierte MySQL-Datenbank verwenden. Erstellen Sie in MySQL Workbench eine neue Datenbank, nennen Sie sie MyAPI und führen Sie die folgende SQL-Anweisung aus:

CREATE TABLE users
(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(20),
password VARCHAR(50),
created_at TIMESTAMP DEFAULT NOW()
)

Diese SQL-Anweisung erstellt eine Tabelle mit dem Namen „Benutzer“, die vier Felder enthält: ID, Benutzername, Kennwort und erstelltes_at.

Als nächstes müssen wir Zugriffsberechtigungen für die Datenbank erteilen. Öffnen Sie MySQL Workbench, wählen Sie Datenbank -> Benutzer und Berechtigungen -> Konto hinzufügen, erstellen Sie einen neuen Benutzer und weisen Sie dem Benutzer Lese- und Schreibberechtigungen für die MyAPI-Datenbank zu.

5. API schreiben

Nachdem wir das Beego-Projekt erstellt haben, müssen wir dem Projekt einige API-Schnittstellen zum Testen hinzufügen. Im main.go des MyAPI-Projekts fügen wir den folgenden Code hinzu:

package main

import (
    "MyAPI/controllers"
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/orm"
    _ "github.com/go-sql-driver/mysql"
)

func init() {
    orm.RegisterDriver("mysql", orm.DRMySQL)
    orm.RegisterDataBase("default", "mysql", "username:password@tcp(127.0.0.1:3306)/MyAPI?charset=utf8")
    orm.RegisterModel(new(models.User))
    orm.RunSyncdb("default", false, true)
}

func main() {
    beego.Router("/api/user/:id", &controllers.UserController{})
    beego.Run()
}

Im obigen Code verwenden wir die beego.Router()-Methode, um den API-Pfad „/api/user/:id“ mit dem Steuerelement zu verbinden controllers.UserController{} Gerätebindung. Wir verwenden außerdem die ORM-Technologie (Object Relational Mapping), um mit der MySQL-Datenbank zu interagieren, die Standarddatenbank mithilfe der RegisterDataBase()-Methode zu registrieren, die Benutzertabelle in der Datenbank zu erstellen und die Benutzerstruktur als ORM-Modell zu registrieren.

Beim Schreiben des Controllers.UserController{} haben wir den folgenden Code hinzugefügt, um die HTTP-GET-Anfrage zu verarbeiten und einen bestimmten Benutzer abzurufen:

func (c *UserController) Get() {
    o := orm.NewOrm()
    user := models.User{}
    id, _ := strconv.Atoi(c.Ctx.Input.Param(":id"))
    user.ID = id
    err := o.Read(&user)
    if err != nil {
        c.Data["json"] = err.Error()
    } else {
        c.Data["json"] = user
    }
    c.ServeJSON()
}

6. Testen Sie die API-Schnittstelle

In diesem Artikel verwenden wir GoConvey, um die zu testen API-Schnittstelle. Wir müssen dem Beego-Projekt ein Verzeichnis mit dem Namen „tests“ hinzufügen und im Verzeichnis eine Testdatei mit dem Namen „user_test.go“ erstellen.

package tests

import (
    "MyAPI/models"
    "github.com/astaxie/beego/orm"
    "net/http"
    "net/http/httptest"
    "testing"
    "github.com/smartystreets/goconvey/convey"
)

func TestGetUser(t *testing.T) {
    convey.Convey("GetUser", t, func() {
        o := orm.NewOrm()
        user := models.User{Username: "testuser", Password: "testpass"}
        id, _ := o.Insert(&user)
        req, _ := http.NewRequest("GET", "/api/user/"+strconv.Itoa(int(id)), nil)
        resp := httptest.NewRecorder()
        beego.BeeApp.Handlers.ServeHTTP(resp, req)
        convey.So(resp.Code, convey.ShouldEqual, 200)
    })
}

Für den obigen Code haben wir das von GoConvey bereitgestellte Förderpaket verwendet, um die API-Schnittstelle zu testen. Wir verwenden ORM zunächst, um einen neuen Benutzer namens testuser zu erstellen, diesen Benutzer über eine HTTP-GET-Anfrage abzurufen und verwenden dann die Methode „conveyr.So()“, um zu bestimmen, ob der HTTP-Status zum Abrufen von Benutzerinformationen 200 ist.

7. Starten Sie den Test

Geben Sie über die Befehlszeile das Verzeichnis des MyAPI-Projekts ein und führen Sie den folgenden Befehl aus:

go test ./tests/...

Dieser Befehl testet alle Testfälle im MyAPI-Projekt und zeigt die Testergebnisse an.

8. Zusammenfassung

Dieser Artikel stellt den grundlegenden Prozess der Verwendung von Beego für API-Tests vor. Mit Hilfe des Beego-Frameworks und des GoConvey-Tools können API-Tests besser durchgeführt werden und eine bessere Garantie für unsere Projekte bieten. Gleichzeitig müssen wir weiterhin neue Technologien und Tools erlernen, unsere Begeisterung für Entwicklung und Tests aufrechterhalten und unser technisches Niveau verbessern.

Das obige ist der detaillierte Inhalt vonPraktische Anwendung: API-Tests mit Beego. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!