Integration testing of go-zero: realizing automated non-destructive testing of API services

As Internet companies continue to grow, software development becomes more and more complex, and testing becomes more and more important. In order to ensure the correctness and stability of the program, various types of tests must be performed. Among them, automated testing is a very important way. It can improve the efficiency of testing work, reduce error rates, and allow repeated execution of test cases to detect problems early. However, in the actual operation process, we will also encounter various problems, such as Issues such as selection of testing tools, writing of test cases, and setting up of test environment.

go-zero is an open source Go language framework. It is developed based on the native standard library of the Go language and supports the rapid construction of high-performance, distributed API services. At the same time, go-zero also provides a very rich The test support function can help us realize automated non-destructive testing of API services and overcome many difficulties in the automated testing process.

This article will start with the test support function of go-zero and introduce in detail how to use go-zero to implement automated non-destructive testing of API services.

1. Test support function of go-zero

go-zero provides a wealth of test support functions, including unit testing, HTTP testing, integration testing, performance testing and server-side testing, etc. . Among them, integration testing is a very important part of go-zero's testing support functions.

go-zero's integration testing adopts a pluggable method and supports a variety of testing tools. You can choose different testing frameworks for testing according to specific needs. Currently supported testing tools include webtest, postman, resty, etc.

2. Use go-zero for automated non-destructive testing of API services

Next, we will use examples to demonstrate how to use go-zero's integration testing to perform automated non-destructive testing of API services.

1. Configuring the test environment

Before conducting the integration test, we need to configure the test environment first. In this example, we will use docker-compose to build the environment. The configuration file is as follows:

version: '3'

services:
  api:
    image: your-api-image:latest
    ports:
      - "8888:8888"
    environment:
      - MYSQL_DSN=root:@tcp(mysql:3306)/test
      - REDIS_DSN=redis:6379
      - REDIS_KEY_PREFIX=test
      - SERVICE_PORT=8888
    depends_on:
      - mysql
      - redis

  mysql:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: ''
    volumes:
      - ./docker/mysql:/docker-entrypoint-initdb.d
      - ./docker/mysql/data:/var/lib/mysql

  redis:
    image: redis:3.2
    restart: always
    volumes:
      - ./docker/redis:/data
    command: redis-server --appendonly yes

In the above configuration file, three services are defined, namely API service, MySQL database and Redis cache. The API service needs to expose port 8888 and relies on the MySQL database and Redis cache.

2. Writing test cases

After configuring the test environment, we need to write test cases. In this example, we will use webtest for testing. Webtest is a testing framework for web applications, supporting HTTP protocol and WebSocket protocol. It provides a rich API that allows us to simulate HTTP requests and responses and verify whether the content of the request and response meets expectations.

The following is an example of using webtest to write test cases:

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/franktrue/grpc-demo/api"
    "github.com/franktrue/grpc-demo/internal/config"
    "github.com/franktrue/grpc-demo/internal/server"
    "github.com/franktrue/grpc-demo/internal/svc"
)

func TestCreateUser(t *testing.T) {
    cfg := config.TestConfig()
    s := server.NewServer(cfg)
    defer s.Stop()

    testCases := []struct {
        name      string
        req       *api.CreateUserRequest
        expectErr bool
    }{
        {
            name: "test createUser success",
            req: &api.CreateUserRequest{
                Name: "testUser",
                Age:  20,
            },
            expectErr: false,
        }, 
        {
            name: "test createUser failed",
            req: &api.CreateUserRequest{
                Name: "",
                Age:  20,
            },
            expectErr: true,
        },
    }

    for _, tc := range testCases {
        resp, err := s.CreateUser(nil, tc.req)
        if tc.expectErr {
            assert.NotNil(t, err, tc.name)
        } else {
            assert.Nil(t, err, tc.name)
            assert.NotNil(t, resp, tc.name)
        }
    }
}

In the above code, we use the testify framework for assertions. In the for loop of the test case, we test the two test cases respectively. The expected result is that the first use case can successfully create the user, while the second use case will fail due to illegal parameters. If the test case is consistent with expectations, the assertion passes; if the test case is inconsistent with expectations, the assertion fails.

3. Run the test case

After writing the test case, we can use the go test command to run the test case:

go test -v ./tests/users_test.go

After running the test case , we can see the execution results in the terminal. If the test case is executed successfully, the OK result will be output; if the test case fails, detailed error information will be output.

In this way, we have completed the automated non-destructive testing of the API service. In this process, we made full use of go-zero's powerful test support function and the ease of use and flexibility of the webtest test framework to provide API The correctness and stability of the service provide a solid guarantee.

The above is the detailed content of Integration testing of go-zero: realizing automated non-destructive testing of API services. For more information, please follow other related articles on the PHP Chinese website!