OpenAPIのサーバーでインテグレーションテストを書く

openapi: 3.0.0
info:
  description: "schema"
  version: "1.0.0"
  title: "integration test"
  contact:
    name: "integration test"
servers:
  - url: "http://localhost:80"
    description: local
tags:
  - name: "user"
    description: ユーザー
security:
  - Bearer: []
paths:
  /user:
    get:
      tags:
        - user
      operationId: FindUsers
      summary: 全ユーザー取得
      description: 全ユーザー取得
      responses:
        200:
          description: OK
          content:
            application/json:
              schema:
                title: Users
                type: array
                items: { $ref: "#/components/schemas/User" }
        500:
          description: Internal Server Error
    post:
      tags:
        - user
      operationId: CreateUser
      summary: ユーザー作成
      description: ユーザー作成
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/User"
      responses:
        200:
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ID"
        500:
          description: Internal Server Error
  /user/{id}:
    get:
      tags:
        - user
      operationId: GetUserByID
      summary: 指定したIDのユーザー取得
      description: 指定したIDのユーザー取得
      parameters:
        - in: path
          name: id
          schema:
            type: integer
            format: int64
          required: true
      responses:
        200:
          description: OK
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/User"
        500:
          description: Internal Server Error
    put:
      tags:
        - user
      operationId: UpdateUser
      summary: 指定したIDのユーザー更新
      description: 指定したIDのユーザー更新
      parameters:
        - in: path
          name: id
          schema:
            type: integer
            format: int64
          required: true
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/User"
      responses:
        200:
          description: OK
        500:
          description: Internal Server Error
    delete:
      tags:
        - user
      operationId: DeleteUser
      summary: 指定したIDのユーザー削除
      description: 指定したIDのユーザー削除
      parameters:
        - in: path
          name: id
          schema:
            type: integer
            format: int64
          required: true
      responses:
        200:
          description: OK
        500:
          description: Internal Server Error

components:
  schemas:
    ID:
      title: ID
      type: object
      properties:
        id:
          type: integer
          format: int64
      required:
        - id
    User:
      title: User
      type: object
      properties:
        id:
          type: integer
          format: int64
          readOnly: true
        name:
          type: string
        email:
          type: string
        created_at:
          type: string
          format: date-time
          readOnly: true
      required:
        - id
        - name
        - email
        - created_at

package main

import (
	"encoding/json"
	"fmt"
	"integration/openapi"
	"log"
	"net/http"
	"os"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/render"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

func main() {
	db, err := connectDB()
	if err != nil {
		log.Fatalln(err)
		return
	}
	mux := chi.NewRouter()

	mux.Use(middleware.Logger)

	openapi.HandlerFromMux(Controller{db}, mux)

	port := os.Getenv("PORT")
	if port == "" {
		port = "80"
	}
	http.ListenAndServe(":"+port, mux)
}

type User struct {
	gorm.Model
	Email string `db:"email"`
	Name  string `db:"name"`
}

type Controller struct {
	*gorm.DB
}

func (c Controller) FindUsers(w http.ResponseWriter, r *http.Request) {
	users := []User{}
	err := c.DB.Order("id ASC").Find(&users).Error
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	us := make([]openapi.User, len(users))
	for i, user := range users {
		us[i] = openapi.User{
			Id:        int64(user.ID),
			Name:      user.Name,
			Email:     user.Email,
			CreatedAt: user.CreatedAt,
		}
	}
	render.JSON(w, r, us)
}

func (c Controller) GetUserByID(w http.ResponseWriter, r *http.Request, id int64) {
	user := User{}
	err := c.DB.Where("id = ?", id).First(&user).Error
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	render.JSON(w, r, openapi.User{
		Id:        int64(user.ID),
		Name:      user.Name,
		Email:     user.Email,
		CreatedAt: user.CreatedAt,
	})
}

func (c Controller) CreateUser(w http.ResponseWriter, r *http.Request) {
	u := openapi.User{}
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&u)
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	user := &User{
		Name:  u.Name,
		Email: u.Email,
	}
	err = c.DB.Create(&user).Error
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	render.JSON(w, r, openapi.ID{Id: int64(user.ID)})
}

func (c Controller) UpdateUser(w http.ResponseWriter, r *http.Request, id int64) {
	u := openapi.User{}
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&u)
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	user := &User{
		Name:  u.Name,
		Email: u.Email,
	}
	err = c.DB.Where("id = ?", id).Updates(&user).Error
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
}

func (c Controller) DeleteUser(w http.ResponseWriter, r *http.Request, id int64) {
	err := c.DB.Where("id = ?", id).Delete(&User{}).Error
	if err != nil {
		log.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
}

func connectDB() (*gorm.DB, error) {
	dsn := fmt.Sprintf("user=%s password=%s dbname=%s host=%s port=%s sslmode=disable",
		os.Getenv("POSTGRES_USER"),
		os.Getenv("POSTGRES_PASSWORD"),
		os.Getenv("POSTGRES_DB_NAME"),
		os.Getenv("POSTGRES_HOST"),
		os.Getenv("POSTGRES_PORT"),
	)
	return gorm.Open(postgres.Open(dsn), &gorm.Config{})
}

var db *gorm.DB
var dsn string

func TestMain(m *testing.M) {
	// ポートやDBの接続先を変えてサーバーを起動する
	os.Chdir("/app")
	cmd := exec.Command("go", "run", "main.go")
	cmd.Env = append(os.Environ(), "PORT=81", "POSTGRES_DB_NAME="+os.Getenv("POSTGRES_TEST_DB_NAME"))
	stdout, _ := cmd.StdoutPipe()
	fatalIf(cmd.Start())
	go func() {
		// 必要ならサーバーのログを出力
		scanner := bufio.NewScanner(stdout)
		for scanner.Scan() {
			line := scanner.Text()
			fmt.Println(line)
		}
	}()
	os.Chdir("/app/integration_test")

	// DBに接続
	connectDB()

	// サーバーの起動が完了するまで待機
	// ヘルスチェックのエンドポイントがあればそれを叩いた方が良い
	time.Sleep(5 * time.Second)

	fmt.Println("============ test start ============")

	// テスト実行
	exitVal := m.Run()

	// サーバーを終了する
	cmd.Process.Kill()
	cmd.Wait()

	os.Exit(exitVal)
}

func connectDB() {
	dsn = fmt.Sprintf("user=%s password=%s dbname=%s host=%s port=%s sslmode=disable",
		os.Getenv("POSTGRES_USER"),
		os.Getenv("POSTGRES_PASSWORD"),
		os.Getenv("POSTGRES_TEST_DB_NAME"),
		os.Getenv("POSTGRES_HOST"),
		os.Getenv("POSTGRES_PORT"),
	)
	var err error
	db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
	fatalIf(err)
}

func fatalIf(err error) {
	if err != nil {
		log.Fatalln(err)
	}
}

func Test_User(t *testing.T) {
	resetDB()
	client := newClient()
	ctx := context.Background()
	// データ作成
	{
		err := db.Table("users").Create(
			[]map[string]interface{}{
				{"name": "name1", "email": "email1"},
			},
		).Error
		assert.NoError(t, err)
	}
	// ユーザー作成
	{
		res, err := client.CreateUserWithResponse(ctx, openapi.CreateUserJSONRequestBody{Name: "name2", Email: "email2"})
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		assertEqual(t, &openapi.ID{Id: 2}, res.JSON200)
	}
	// ユーザー作成
	{
		res, err := client.CreateUserWithResponse(ctx, openapi.CreateUserJSONRequestBody{Name: "name3", Email: "email3"})
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		assertEqual(t, &openapi.ID{Id: 3}, res.JSON200)
	}
	// ユーザー一覧取得
	{
		res, err := client.FindUsersWithResponse(ctx)
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		want := &[]openapi.User{
			{Id: 1, Name: "name1", Email: "email1"},
			{Id: 2, Name: "name2", Email: "email2"},
			{Id: 3, Name: "name3", Email: "email3"},
		}
		assertEqual(t, want, res.JSON200, cmpopts.IgnoreFields(openapi.User{}, "CreatedAt"))
	}
	// ユーザー取得
	{
		res, err := client.GetUserByIDWithResponse(ctx, 1)
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		want := &openapi.User{Id: 1, Name: "name1", Email: "email1"}
		assertEqual(t, want, res.JSON200, cmpopts.IgnoreFields(openapi.User{}, "CreatedAt"))
	}
	// ユーザー更新
	{
		res, err := client.UpdateUserWithResponse(ctx, 1, openapi.UpdateUserJSONRequestBody{Name: "name1_update", Email: "email1_update"})
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
	}
	// ユーザー取得
	{
		res, err := client.GetUserByIDWithResponse(ctx, 1)
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		want := &openapi.User{Id: 1, Name: "name1_update", Email: "email1_update"}
		assertEqual(t, want, res.JSON200, cmpopts.IgnoreFields(openapi.User{}, "CreatedAt"))
	}
	// ユーザー削除
	{
		res, err := client.DeleteUserWithResponse(ctx, 2)
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
	}
	// ユーザー一覧取得
	{
		res, err := client.FindUsersWithResponse(ctx)
		assert.NoError(t, err)
		assertStatusCode(t, 200, res)
		want := &[]openapi.User{
			{Id: 1, Name: "name1_update", Email: "email1_update"},
			{Id: 3, Name: "name3", Email: "email3"},
		}
		assertEqual(t, want, res.JSON200, cmpopts.IgnoreFields(openapi.User{}, "CreatedAt"))
	}
}

func newClient() *openapi.ClientWithResponses {
	// 認証が必要であればトークンをセットする
	token := ""
	c, err := openapi.NewClientWithResponses("http://localhost:81", openapi.WithRequestEditorFn(
		func(ctx context.Context, req *http.Request) error {
			req.Header.Add("Authorization", "Bearer "+token)
			return nil
		},
	))
	fatalIf(err)
	return c
}

func assertStatusCode(t *testing.T, expect int, actual interface{ StatusCode() int }) bool {
	if expect != actual.StatusCode() {
		assert.Fail(t, "assertStatusCode mismatch", fmt.Sprintf("status code got: %d, want:%d", actual.StatusCode(), expect))
		return false
	}
	return true
}

func assertEqual(t *testing.T, expect, actual interface{}, opts ...cmp.Option) bool {
	if diff := cmp.Diff(actual, expect, opts...); diff != "" {
		assert.Fail(t, "assertEqual mismatch", fmt.Sprintf("differs: (-got +want)\n%s", diff))
		return false
	}
	return true
}

func resetDB() {
	// 原因は不明だがテーブルの作成に失敗することがあるので、最大5回リトライする
	for i := 0; i < 5; i++ {
		out, err := exec.Command("psql", dsn, "-f", "./reset.sql").Output()
		fatalIf(err)
		// 成功したときは4行以上出力される
		if len(strings.Split(string(out), "\n")) >= 4 {
			return
		}
		fmt.Println("retry reset db")
		time.Sleep(1 * time.Second)
	}
	log.Fatalln("failed to reset db")
}