photoplaces/backend/internal/repository/integration_test.go

package repository

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

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgxpool"
	"gogs.fxtmmsk.ru/foxtime/photoplaces/backend/internal/models"
)

var testPool *pgxpool.Pool

func TestMain(m *testing.M) {
	databaseURL := os.Getenv("DATABASE_URL_TEST")
	if databaseURL == "" {
		databaseURL = os.Getenv("DATABASE_URL")
	}
	if databaseURL == "" {
		log.Println("SKIP: DATABASE_URL_TEST not set")
		return
	}

	ctx := context.Background()
	pool, err := pgxpool.New(ctx, databaseURL)
	if err != nil {
		log.Printf("SKIP: cannot connect to test database: %v", err)
		return
	}
	defer pool.Close()

	testPool = pool
	os.Exit(m.Run())
}

func cleanTables(t *testing.T, tables ...string) {
	t.Helper()
	ctx := context.Background()
	for _, table := range tables {
		if _, err := testPool.Exec(ctx, "DELETE FROM "+table); err != nil {
			t.Fatalf("clean table %s: %v", table, err)
		}
	}
}

func insertTestUser(t *testing.T) *models.User {
	t.Helper()
	ctx := context.Background()
	user := &models.User{
		ID:           uuid.New().String(),
		Email:        uuid.New().String() + "@test.test",
		PasswordHash: "hash",
		Role:         "customer",
		Status:       "active",
		CreatedAt:    time.Now(),
	}
	_, err := testPool.Exec(ctx,
		`INSERT INTO users (id, email, password_hash, role, status, created_at)
		 VALUES ($1, $2, $3, $4, $5, $6)`,
		user.ID, user.Email, user.PasswordHash, user.Role, user.Status, user.CreatedAt)
	if err != nil {
		t.Fatalf("insert test user: %v", err)
	}
	return user
}

func insertTestPlace(t *testing.T, ownerID string, hourlyRate *int) *models.Place {
	t.Helper()
	ctx := context.Background()
	p := &models.Place{
		ID:         uuid.New().String(),
		Type:       "studio",
		OwnerID:    ownerID,
		Title:      "Test Place " + uuid.New().String()[:8],
		Lat:        55.75,
		Lng:        37.61,
		Status:     "published",
		HourlyRate: hourlyRate,
		Currency:   "RUB",
		Rating:     0,
		CreatedAt:  time.Now(),
		UpdatedAt:  time.Now(),
	}
	_, err := testPool.Exec(ctx,
		`INSERT INTO places (id, type, owner_id, title, coordinates, status, hourly_rate, currency, rating, created_at, updated_at)
		 VALUES ($1, $2, $3, $4, ST_SetSRID(ST_MakePoint($5, $6), 4326), $7, $8, $9, $10, $11, $12)`,
		p.ID, p.Type, p.OwnerID, p.Title, p.Lng, p.Lat, p.Status, p.HourlyRate, p.Currency, p.Rating, p.CreatedAt, p.UpdatedAt)
	if err != nil {
		t.Fatalf("insert test place: %v", err)
	}
	return p
}

func insertTestTag(t *testing.T) *models.Tag {
	t.Helper()
	ctx := context.Background()
	tag := &models.Tag{
		ID:       uuid.New().String(),
		Name:     "Test Tag " + uuid.New().String()[:8],
		Category: "style",
	}
	_, err := testPool.Exec(ctx,
		`INSERT INTO tags (id, name, category) VALUES ($1, $2, $3)`,
		tag.ID, tag.Name, tag.Category)
	if err != nil {
		t.Fatalf("insert test tag: %v", err)
	}
	return tag
}

func insertTestPlaceTag(t *testing.T, placeID, tagID string) {
	t.Helper()
	if _, err := testPool.Exec(context.Background(),
		`INSERT INTO place_tags (place_id, tag_id) VALUES ($1, $2)`, placeID, tagID); err != nil {
		t.Fatalf("insert place_tag: %v", err)
	}
}