main_test.go

package kohaku

import (
	"context"
	"log"
	"os"
	"testing"

	ch "github.com/ClickHouse/clickhouse-go/v2"
	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"
	"github.com/stretchr/testify/assert"
	"github.com/testcontainers/testcontainers-go"

	"github.com/testcontainers/testcontainers-go/modules/clickhouse"
)

const (
	clickhouseUser     = "default"
	clickhousePassword = "default"
	clickhouseDB       = "default"
)

var (
	conn *driver.Conn

	addr   []string
	server *Server

	config = &Config{
		TLSFullchainFile:    "cert/server/server.pem",
		TLSPrivkeyFile:      "cert/server/server.key",
		TLSVerifyCacertPath: "cert/client/ca.pem",
		HTTPS:               true,
		ListenAddr:          "0.0.0.0",
		ListenPort:          15890,
	}
)

// https://github.com/rilldata/rill/blob/65e7cb07060deab31ef1fef32e345d64d9611cb4/runtime/queries/metricsview_toplist_test.go#L25

func TestMain(m *testing.M) {
	ctx := context.Background()

	clickHouseContainer, err := clickhouse.RunContainer(ctx,
		testcontainers.WithImage("clickhouse/clickhouse-server:latest"),
		clickhouse.WithUsername(clickhouseUser),
		clickhouse.WithPassword(clickhousePassword),
		clickhouse.WithDatabase(clickhouseDB),
	)
	if err != nil {
		log.Fatalf("failed to start container: %s", err)
	}

	defer func() {
		if err := clickHouseContainer.Terminate(ctx); err != nil {
			log.Fatalf("failed to terminate container: %s", err)
		}
	}()

	// state, err := clickHouseContainer.State(ctx)
	// if err != nil {
	// 	log.Fatalf("failed to get container state: %s", err) // nolint:gocritic
	// }

	host, err := clickHouseContainer.Host(ctx)
	if err != nil {
		log.Fatalf("failed to get container host: %s", err)
	}
	port, err := clickHouseContainer.MappedPort(ctx, "9000")
	if err != nil {
		log.Fatalf("failed to get container port: %s", err)
	}

	addr = []string{host + ":" + port.Port()}
	conn, err := ch.Open(&ch.Options{
		Addr: addr,
		Auth: ch.Auth{
			Username: clickhouseUser,
			Password: clickhousePassword,
			Database: clickhouseDB,
		},
	})
	if err != nil {
		log.Fatalf("failed to open ClickHouse connection: %s", err)
	}

	err = conn.Ping(ctx)
	if err != nil {
		log.Fatalf("failed to ping ClickHouse: %s", err)
	}

	// ここでテストを実行する

	code := m.Run()

	// 処理が終わったら、deferによってコンテナが自動的に停止して削除される

	os.Exit(code)
}

func open() driver.Conn {
	conn, err := ch.Open(&ch.Options{
		Addr: addr,
		Auth: ch.Auth{
			Username: clickhouseUser,
			Password: clickhousePassword,
			Database: clickhouseDB,
		},
	})
	if err != nil {
		log.Fatalf("failed to open ClickHouse connection: %s", err)
	}

	return conn
}

func TestDummy(t *testing.T) {
	ctx := context.Background()
	var err error

	conn := open()

	err = conn.Exec(ctx, "CREATE TABLE IF NOT EXISTS test (id UInt32, name String) ENGINE = Memory")
	assert.NoError(t, err)

	err = conn.Exec(ctx, "INSERT INTO test (id, name) VALUES (1, 'Alice')")
	assert.NoError(t, err)

	rows, err := conn.Query(ctx, "SELECT * FROM test")
	assert.NoError(t, err)
	assert.Len(t, rows.Columns(), 2)

	log.Println("ダミーのテストが実行されました。")
}

func newTestServer(c *Config, conn driver.Conn) *Server {
	s := &Server{
		config: c,
		conn:   conn,
	}

	s.setupEchoServer()

	return s
}