test: add e2e tests for Add Artist flow (section 1.1)

- Add testutil package with DB/HTTP helpers and cleanup utilities - Add e2e tests covering artist search, album fetch, sync persistence - Test idempotent sync, album filtering, library list endpoints - Requires running PostgreSQL, MetadataService, and API server
2026-04-29 11:25:30 +02:00
parent 41fb033d30
commit 25deaf4621
2 changed files with 886 additions and 0 deletions
@@ -0,0 +1,286 @@
+// Package testutil provides utilities for e2e tests.
+// Tests require running services: PostgreSQL, MetadataService (gRPC), and the API server.
+package testutil
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Config holds test environment configuration.
+type Config struct {
+	APIBaseURL  string
+	DatabaseURL string
+}
+
+// DefaultConfig returns configuration from environment variables or defaults.
+func DefaultConfig() Config {
+	return Config{
+		APIBaseURL:  getEnv("TEST_API_URL", "http://localhost:3000"),
+		DatabaseURL: getEnv("TEST_DATABASE_URL", "postgresql://music:music@localhost:5433/music_aggregator"),
+	}
+}
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}
+
+// TestEnv provides test environment with database and HTTP client.
+type TestEnv struct {
+	Config Config
+	DB     *pgxpool.Pool
+	Client *http.Client
+	t      *testing.T
+}
+
+// NewTestEnv creates a new test environment.
+// It connects to the database and verifies the API is reachable.
+func NewTestEnv(t *testing.T) *TestEnv {
+	t.Helper()
+
+	cfg := DefaultConfig()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	pool, err := pgxpool.New(ctx, cfg.DatabaseURL)
+	if err != nil {
+		t.Fatalf("failed to connect to database: %v", err)
+	}
+
+	if err := pool.Ping(ctx); err != nil {
+		t.Fatalf("failed to ping database: %v", err)
+	}
+
+	client := &http.Client{Timeout: 30 * time.Second}
+
+	env := &TestEnv{
+		Config: cfg,
+		DB:     pool,
+		Client: client,
+		t:      t,
+	}
+
+	if err := env.waitForAPI(ctx); err != nil {
+		t.Fatalf("API not reachable: %v", err)
+	}
+
+	return env
+}
+
+// Close cleans up test environment resources.
+func (e *TestEnv) Close() {
+	if e.DB != nil {
+		e.DB.Close()
+	}
+}
+
+// waitForAPI waits for the API to become available.
+func (e *TestEnv) waitForAPI(ctx context.Context) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return fmt.Errorf("timeout waiting for API")
+		default:
+			resp, err := e.Client.Get(e.Config.APIBaseURL + "/health")
+			if err == nil && resp.StatusCode == http.StatusOK {
+				resp.Body.Close()
+				return nil
+			}
+			if resp != nil {
+				resp.Body.Close()
+			}
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+}
+
+// CleanupArtist removes an artist and all related data from the database.
+func (e *TestEnv) CleanupArtist(ctx context.Context, foreignArtistID string) error {
+	_, err := e.DB.Exec(ctx, `
+		DELETE FROM artist_metadata WHERE foreign_artist_id = $1
+	`, foreignArtistID)
+	return err
+}
+
+// CleanupArtistByName removes artists matching a name pattern.
+func (e *TestEnv) CleanupArtistByName(ctx context.Context, namePattern string) error {
+	_, err := e.DB.Exec(ctx, `
+		DELETE FROM artist_metadata WHERE name ILIKE $1
+	`, namePattern)
+	return err
+}
+
+// APIRequest makes an HTTP request to the API.
+type APIRequest struct {
+	Method string
+	Path   string
+	Body   any
+}
+
+// APIResponse holds the response from an API call.
+type APIResponse struct {
+	StatusCode int
+	Body       []byte
+}
+
+// Do executes an API request and returns the response.
+func (e *TestEnv) Do(req APIRequest) (*APIResponse, error) {
+	var bodyReader io.Reader
+	if req.Body != nil {
+		bodyBytes, err := json.Marshal(req.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(bodyBytes)
+	}
+
+	httpReq, err := http.NewRequest(req.Method, e.Config.APIBaseURL+req.Path, bodyReader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	if req.Body != nil {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+
+	resp, err := e.Client.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	return &APIResponse{
+		StatusCode: resp.StatusCode,
+		Body:       body,
+	}, nil
+}
+
+// POST is a convenience method for POST requests.
+func (e *TestEnv) POST(path string, body any) (*APIResponse, error) {
+	return e.Do(APIRequest{Method: http.MethodPost, Path: path, Body: body})
+}
+
+// GET is a convenience method for GET requests.
+func (e *TestEnv) GET(path string) (*APIResponse, error) {
+	return e.Do(APIRequest{Method: http.MethodGet, Path: path})
+}
+
+// DecodeJSON decodes the response body into the given value.
+func (r *APIResponse) DecodeJSON(v any) error {
+	return json.Unmarshal(r.Body, v)
+}
+
+// AssertStatus checks that the response has the expected status code.
+func (r *APIResponse) AssertStatus(t *testing.T, expected int) {
+	t.Helper()
+	if r.StatusCode != expected {
+		t.Errorf("expected status %d, got %d. Body: %s", expected, r.StatusCode, string(r.Body))
+	}
+}
+
+// CountArtists returns the number of artists in the database.
+func (e *TestEnv) CountArtists(ctx context.Context) (int64, error) {
+	var count int64
+	err := e.DB.QueryRow(ctx, "SELECT COUNT(*) FROM artist_metadata").Scan(&count)
+	return count, err
+}
+
+// CountAlbums returns the number of albums in the database.
+func (e *TestEnv) CountAlbums(ctx context.Context) (int64, error) {
+	var count int64
+	err := e.DB.QueryRow(ctx, "SELECT COUNT(*) FROM albums").Scan(&count)
+	return count, err
+}
+
+// GetArtistByForeignID retrieves an artist by foreign artist ID.
+func (e *TestEnv) GetArtistByForeignID(ctx context.Context, foreignID string) (map[string]any, error) {
+	var result map[string]any
+	row := e.DB.QueryRow(ctx, `
+		SELECT id, foreign_artist_id, name, sort_name, artist_type, genres
+		FROM artist_metadata
+		WHERE foreign_artist_id = $1
+	`, foreignID)
+
+	var id, foreignArtistID, name string
+	var sortName, artistType *string
+	var genres []byte
+
+	err := row.Scan(&id, &foreignArtistID, &name, &sortName, &artistType, &genres)
+	if err != nil {
+		return nil, err
+	}
+
+	result = map[string]any{
+		"id":                id,
+		"foreign_artist_id": foreignArtistID,
+		"name":              name,
+		"sort_name":         sortName,
+		"artist_type":       artistType,
+	}
+
+	var genreList []map[string]any
+	if err := json.Unmarshal(genres, &genreList); err == nil {
+		result["genres"] = genreList
+	}
+
+	return result, nil
+}
+
+// GetAlbumsByArtistForeignID retrieves albums for an artist by foreign artist ID.
+func (e *TestEnv) GetAlbumsByArtistForeignID(ctx context.Context, foreignArtistID string) ([]map[string]any, error) {
+	rows, err := e.DB.Query(ctx, `
+		SELECT a.id, a.foreign_album_id, a.title, a.album_type, a.release_date, a.monitored
+		FROM albums a
+		JOIN artist_metadata am ON a.artist_metadata_id = am.id
+		WHERE am.foreign_artist_id = $1
+		ORDER BY a.release_date DESC NULLS LAST
+	`, foreignArtistID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var albums []map[string]any
+	for rows.Next() {
+		var id, title string
+		var foreignAlbumID, albumType *string
+		var releaseDate *time.Time
+		var monitored bool
+
+		if err := rows.Scan(&id, &foreignAlbumID, &title, &albumType, &releaseDate, &monitored); err != nil {
+			return nil, err
+		}
+
+		album := map[string]any{
+			"id":               id,
+			"foreign_album_id": foreignAlbumID,
+			"title":            title,
+			"album_type":       albumType,
+			"monitored":        monitored,
+		}
+		if releaseDate != nil {
+			album["release_date"] = releaseDate.Format("2006-01-02")
+		}
+		albums = append(albums, album)
+	}
+
+	return albums, nil
+}