Practical application: API testing using Beego

In recent years, due to the development of Internet technology, API (Application Programming Interface) development and testing has become an important part of Internet companies. Due to the simple process of API testing, high efficiency and high code reuse rate, more and more Internet companies are beginning to use automated testing to test their API interfaces. This article will introduce in detail how to use the Beego framework for API testing.

1. Introduction to Beego framework

Beego is a Web framework based on the Go language. Due to its high efficiency, simplicity, and ease of learning, it is used by more and more developers. In addition, Beego also provides a wealth of tools and plug-ins, including ORM, Websocket, Redis, CORS, Swagger and other tools, which can greatly improve development efficiency.

2. Development tools

Before starting development, you must first prepare the necessary development tools. The development environment used in this article is as follows:

1. Operating system: Windows 10

2. Go version: go1.11.4 windows/amd64

3. Beego version: 1.12. 1

4. Testing framework: GoConvey

5. Browser: Chrome

6. Code editor: Sublime Text 3

7. Database: MySQL

3. Installation and configuration

1. Install Go

First, you need to install the Go language development environment. Download the corresponding installation package from the official website (https://golang.org/dl/). After the download is complete, double-click to run the installation package to complete the installation.

2. Install Beego

After installing the Go language, you need to install the Beego framework. Beego can be installed through the following command:

go get -u github.com/astaxie/beego

This command will download the Beego framework to the GOPATH path.

3. Install GoConvey

GoConvey is a unit testing framework for the Go language that can detect all test cases in the project and automatically execute these test cases. The method to install GoConvey is as follows:

go get github.com/smartystreets/goconvey

4. Install MySQL

In this article, we use the MySQL database. Please go to the official MySQL website to download and install: https://dev.mysql.com/downloads/mysql/

When installing MySQL, it is recommended to install the built-in MySQL Workbench.

4. Create a Beego project

There are many ways to create a Beego project. You can use the command line or the tool web provided by Beego. In this article, we use the command line to create a project called "MyAPI". Enter the following command on the command line:

bee new MyAPI

Then a Beego project named "MyAPI" will be created in the current directory.

Next, we need to use the MySQL database installed previously. In MySQL Workbench, create a new database and name it MyAPI, execute the following SQL statement:

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

This SQL statement creates a table named users, containing four fields: id, username, password and created_at .

Next, we need to grant access permissions to the database. Open MySQL Workbench, select Database -> Users and Privileges -> Add Account, create a new user, and assign the user read and write permissions to the MyAPI database.

5. Writing API

After creating the Beego project, we need to add some API interfaces to the project for testing. In the main.go of the MyAPI project, we add the following code:

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()
}

In the above code, we use the beego.Router() method to connect the API path "/api/user/:id" to controllers.UserController {}This controller is bound. We also use ORM (Object Relational Mapping) technology to interact with the MySQL database, register the default database using the RegisterDataBase() method, create the users table in the database, and register the User structure as an ORM model.

When writing the controllers.UserController{} controller, we added the following code to handle the HTTP GET request and obtain a specific user:

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. Test API interface

In this article, we use GoConvey to test the API interface. We need to add a directory named tests to the Beego project and create a test file named user_test.go in the directory.

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)
    })
}

For the above code, we used the convey package provided by GoConvey to test the API interface. We first use ORM to create a new user named testuser, and obtain this user through HTTP GET request, and then use the convey.So() method to determine whether the HTTP status of obtaining user information is 200.

7. Start the test

Enter the directory of the MyAPI project through the command line and execute the following command:

go test ./tests/...

This command will test all test cases in the MyAPI project , and display the test results.

8. Summary

This article introduces the basic process of using Beego for API testing. With the help of Beego framework and GoConvey tool, we can better conduct API testing and provide better guarantee for our projects. At the same time, we also need to continue to learn new technologies and tools, maintain our enthusiasm for development and testing, and improve our technical level.

The above is the detailed content of Practical application: API testing using Beego. For more information, please follow other related articles on the PHP Chinese website!