Go에서 REST API 테스트: Go&#s 표준 테스트 라이브러리를 사용한 단위 및 통합 테스트 가이드

소개

이 기사에서는 golang에서 나머지 API를 생성할 때 개발 경험을 개선하기 위해 단위 테스트 및 통합 테스트를 사용하는 방법을 안내합니다.

• 단위 테스트는 애플리케이션의 가장 작은 개별 부분의 기능을 확인하도록 설계되었으며, 종종 단일 기능이나 방법에 중점을 둡니다. 이러한 테스트는 각 구성 요소가 자체적으로 예상대로 작동하는지 확인하기 위해 코드의 다른 부분과 별도로 수행됩니다.

• 통합 테스트는 애플리케이션의 다양한 모듈이나 구성 요소가 어떻게 함께 작동하는지 평가합니다. 이 기사에서는 Go 애플리케이션의 통합 테스트, 특히 SQL 쿼리를 성공적으로 만들고 실행하여 PostgreSQL 데이터베이스와 올바르게 상호 작용하는지 확인하는 것에 중점을 둘 것입니다.

이 기사에서는 귀하가 golang에 익숙하다고 가정하고 golang에서 나머지 API를 생성하는 방법의 주요 초점은 경로에 대한 테스트 생성(단위 테스트) 및 참조용 SQL 쿼리 기능 테스트(통합 테스트)에 있을 것입니다. github을 방문하세요. 프로젝트를 살펴보세요.

설정

위에 링크된 것과 유사한 프로젝트를 설정했다고 가정하면 다음과 유사한 폴더 구조를 갖게 됩니다

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

golang에서의 테스트는 테스트 작성에 필요한 도구를 제공하는 내장 테스트 패키지 덕분에 다른 언어와 쉽게 비교할 수 있습니다.
테스트 파일 이름은 _test.go로 지정됩니다. 이 접미사는 go test 명령을 실행할 때 이 파일을 실행 대상으로 지정할 수 있습니다.

우리 프로젝트의 진입점은 cmd 폴더에 있는 main.go 파일입니다

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

코드에서 데이터베이스 연결과 포트 번호를 전달하여 새로운 API 서버를 생성하는 것을 볼 수 있습니다. 서버를 생성한 후 명시된 포트에서 실행합니다.

NewAPIServer 명령은 api.go 파일에서 옵니다

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

이 API에서는 mux를 http 라우터로 사용하고 있습니다.

통합 테스트

사용자 엔터티와 관련된 SQL 쿼리를 처리하는 사용자 Store 구조체가 있습니다.

// store.go
package user

import (
    "errors"
    "finance-crud-app/internal/types"
    "fmt"
    "log"

    "github.com/jmoiron/sqlx"
)

var (
    CreateUserError   = errors.New("cannot create user")
    RetrieveUserError = errors.New("cannot retrieve user")
    DeleteUserError   = errors.New("cannot delete user")
)

type Store struct {
    db *sqlx.DB
}

func NewStore(db *sqlx.DB) *Store {
    return &Store{db: db}
}

func (s *Store) CreateUser(user types.User) (user_id int, err error) {
    query := `
    INSERT INTO users
    (firstName, lastName, email, password)
    VALUES (, , , )
    RETURNING id`

    var userId int
    err = s.db.QueryRow(query, user.FirstName, user.LastName, user.Email, user.Password).Scan(&userId)
    if err != nil {
        return -1, CreateUserError
    }

    return userId, nil
}

func (s *Store) GetUserByEmail(email string) (types.User, error) {
    var user types.User

    err := s.db.Get(&user, "SELECT * FROM users WHERE email = ", email)
    if err != nil {
        return types.User{}, RetrieveUserError
    }

    if user.ID == 0 {
        log.Fatalf("user not found")
        return types.User{}, RetrieveUserError
    }

    return user, nil
}

func (s *Store) GetUserByID(id int) (*types.User, error) {
    var user types.User
    err := s.db.Get(&user, "SELECT * FROM users WHERE id = ", id)
    if err != nil {
        return nil, RetrieveUserError
    }

    if user.ID == 0 {
        return nil, fmt.Errorf("user not found")
    }

    return &user, nil
}

func (s *Store) DeleteUser(email string) error {

    user, err := s.GetUserByEmail(email)
    if err != nil {
        return DeleteUserError
    }
    // delete user records first
    _, err = s.db.Exec("DELETE FROM records WHERE userid = ", user.ID)
    if err != nil {
        return DeleteUserError
    }

    _, err = s.db.Exec("DELETE FROM users WHERE email = ", email)
    if err != nil {
        return DeleteUserError
    }
    return nil
}

위 파일에는 3가지 포인터 수신 방법이 있습니다.

• 사용자 생성
• GetUserByEmail
• GetUserById

이러한 방법이 기능을 수행하려면 외부 시스템과 상호 작용해야 합니다. 이 경우에는 Postgres DB입니다.

이 방법을 테스트하기 위해 먼저 store_test.go 파일을 만듭니다. Go에서는 일반적으로 테스트 대상 파일 이름을 따서 테스트 파일 이름을 지정하고 접미사 _test.go .
를 추가합니다.

// store_test.go

package user_test

import (
    "finance-crud-app/internal/db"
    "finance-crud-app/internal/services/user"
    "finance-crud-app/internal/types"
    "log"
    "os"
    "testing"

    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

var (
    userTestStore *user.Store
    testDB        *sqlx.DB
)

func TestMain(m *testing.M) {
    // database
    ConnStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
    testDB, err := db.NewPGStorage(ConnStr)
    if err != nil {
        log.Fatalf("could not connect %v", err)
    }
    defer testDB.Close()
    userTestStore = user.NewStore(testDB)

    code := m.Run()
    os.Exit(code)
}

func TestCreateUser(t *testing.T) {
    test_data := map[string]struct {
        user   types.User
        result any
    }{
        "should PASS valid user email used": {
            user: types.User{
                FirstName: "testfirsjjlkjt-1",
                LastName:  "testlastkjh-1",
                Email:     "validuser@email.com",
                Password:  "00000000",
            },
            result: nil,
        },
        "should FAIL invalid user email used": {
            user: types.User{
                FirstName: "testFirstName1",
                LastName:  "testLastName1",
                Email:     "test1@email.com",
                Password:  "800890",
            },
            result: user.CreateUserError,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            value, got := userTestStore.CreateUser(tc.user)
            if got != tc.result {
                t.Errorf("test fail expected %v got %v instead and value %v", tc.result, got, value)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("validuser@email.com")
        if err != nil {
            t.Errorf("could not delete user %v got error %v", "validuser@email.com", err)
        }
    })
}

func TestGetUserByEmail(t *testing.T) {
    test_data := map[string]struct {
        email  string
        result any
    }{
        "should pass valid user email address used": {
            email:  "test1@email.com",
            result: nil,
        },
        "should fail invalid user email address used": {
            email:  "validuser@email.com",
            result: user.RetrieveUserError,
        },
    }

    for name, tc := range test_data {
        got, err := userTestStore.GetUserByEmail(tc.email)
        if err != tc.result {
            t.Errorf("test fail expected %v instead got %v", name, got)
        }
    }
}

func TestGetUserById(t *testing.T) {
    testUserId, err := userTestStore.CreateUser(types.User{
        FirstName: "userbyid",
        LastName:  "userbylast",
        Email:     "unique_email",
        Password:  "unique_password",
    })
    if err != nil {
        log.Panicf("got %v when creating testuser", testUserId)
    }

    test_data := map[string]struct {
        user_id int
        result  any
    }{
        "should pass valid user id used": {
            user_id: testUserId,
            result:  nil,
        },
        "should fail invalid user id used": {
            user_id: 0,
            result:  user.RetrieveUserError,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            _, got := userTestStore.GetUserByID(tc.user_id)
            if got != tc.result {
                t.Errorf("error retrieving user by id got %v want %v", got, tc.result)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("unique_email")
        if err != nil {
            t.Errorf("could not delete user %v got error %v", "unique_email", err)
        }
    })
}

func TestDeleteUser(t *testing.T) {
    testUserId, err := userTestStore.CreateUser(types.User{
        FirstName: "userbyid",
        LastName:  "userbylast",
        Email:     "delete_user@email.com",
        Password:  "unique_password",
    })
    if err != nil {
        log.Panicf("got %v when creating testuser", testUserId)
    }

    test_data := map[string]struct {
        user_email string
        result     error
    }{
        "should pass user email address used": {
            user_email: "delete_user@email.com",
            result:     nil,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            err = userTestStore.DeleteUser(tc.user_email)
            if err != tc.result {
                t.Errorf("error deletig user got %v instead of %v", err, tc.result)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("delete_user@email.com")
        if err != nil {
            log.Printf("could not delete user %v got error %v", "delete_user@email.com", err)
        }
    })
}

파일을 살펴보며 각 섹션의 기능을 살펴보겠습니다.

첫 번째 작업은 userTestStore 및 testDB 변수를 선언하는 것입니다. 이러한 변수는 각각 사용자 저장소와 db에 대한 포인터를 저장하는 데 사용됩니다. 전역 파일 범위에서 선언한 이유는 테스트 파일의 모든 함수가 포인터에 액세스할 수 있기를 원하기 때문입니다.

TestMain 기능을 사용하면 기본 테스트가 실행되기 전에 몇 가지 설정 작업을 수행할 수 있습니다. 처음에는 postgres 저장소에 연결하고 포인터를 전역 변수에 저장합니다.
우리는 연결하려는 SQL 쿼리를 실행하는 데 사용할 userTestStore를 생성하기 위해 해당 포인터를 사용했습니다.

defer testDB.Close()는 테스트가 완료된 후 데이터베이스 연결을 닫습니다

code := m.Run()은 반환 및 종료 전에 나머지 테스트 기능을 실행합니다.

TestCreateUser 함수는 create_user 함수의 테스트를 처리합니다. 우리의 목표는 고유 이메일이 전달되면 함수가 사용자를 생성하는지 테스트하고, 고유하지 않은 이메일이 이미 다른 사용자를 생성하는 데 사용된 경우 함수가 사용자를 생성할 수 없어야 하는지 테스트하는 것입니다.

먼저 두 사례 시나리오를 테스트하는 데 사용할 테스트 데이터를 만듭니다.

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

테스트 날짜를 매개변수로 사용하여 create_user 함수를 실행하는 맵을 반복하고 반환된 값이 예상한 결과와 동일한지 비교합니다

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

반환된 결과가 예상 결과와 동일하지 않은 경우 테스트가 실패합니다

이 기능의 마지막 부분은 내장된 테스트 패키지 기능 정리를 사용하는 것입니다. 테스트에 포함된 모든 함수가 이미 실행되었을 때 호출될 함수를 등록한 함수입니다. 여기 예시에서는 이 테스트 기능 실행 중에 사용된 사용자 데이터를 지우는 기능을 사용하고 있습니다.

단위 테스트

단위 테스트를 위해 API에 대한 경로 핸들러를 테스트할 예정입니다. 이 경우 사용자 엔터티와 관련된 경로입니다. 아래 내용을 참고하세요.

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

여기에는 테스트하고 싶은 3가지 기능이 있습니다

• 로그인 처리
• 핸들등록
• HandleGetUser

HandleGetUser

이 핸들러의 handlerGetUser 함수는 HTTP 요청 URL에 제공된 사용자 ID를 기반으로 사용자 세부정보를 검색합니다. Mux 라우터를 사용하여 요청 경로 변수에서 사용자 ID를 추출하는 것으로 시작됩니다. userID가 누락되었거나 유효하지 않은 경우(정수가 아님) 400 Bad Request 오류로 응답합니다. 유효성이 검사되면 함수는 데이터 저장소에서 GetUserByID 메서드를 호출하여 사용자 정보를 검색합니다. 검색 중에 오류가 발생하면 500 내부 서버 오류가 반환됩니다. 성공하면 200 OK 상태로 응답하고 응답 본문에 사용자 세부 정보를 JSON으로 보냅니다.

앞서 설명한 것처럼 핸들러 기능을 테스트하려면 routes_test.go를 만들어야 합니다. 아래 내 내용을 확인하세요

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

새 핸들러 함수에는 핸들러 구조체를 생성하기 위한 매개변수로 사용자 저장소가 필요합니다.
실제 저장소가 필요하지 않기 때문에 모의 구조체를 만들고 실제 구조체의 기능을 모의하는 수신자 함수를 만듭니다. 우리는 저장 기능 테스트를 별도로 처리하기 때문에 이렇게 합니다. 따라서 핸들러 테스트에서 코드의 해당 부분을 테스트할 필요가 없습니다.

테스트 함수 TestGetUserHandler는 두 가지 사례 시나리오를 테스트합니다. 첫 번째는 사용자 ID를 제공하지 않고 사용자를 검색하려고 시도하는 것입니다.

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

http 요청이 400 상태 코드로 응답하면 테스트에 통과한 것으로 예상됩니다.

두 번째 테스트 사례 시나리오는 유효한 사용자 ID가 포함된 올바른 URL을 사용하여 사용자 정보를 검색하는 경우입니다. 이 테스트 사례에서는 200 상태 코드가 포함된 응답을 예상했습니다. 그렇지 않으면 해당 테스트는 실패한 것입니다.

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

결론

라우트 핸들러에 대한 테스트를 생성하여 프로젝트에서 단위 테스트를 구현했습니다. 우리는 작은 단위의 코드만 테스트하기 위해 모의 객체를 사용하는 방법을 살펴보았습니다. Postgresql DB와 상호 작용하는 기능에 대한 통합 테스트를 개발할 수 있었습니다.
프로젝트 코드를 직접 사용하고 싶다면 여기 github에서 저장소를 복제하세요

위 내용은 Go에서 REST API 테스트: Go&#s 표준 테스트 라이브러리를 사용한 단위 및 통합 테스트 가이드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!