vars_test.go

package migrate

import (
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"sync"
	"testing"

	dStub "github.com/AccelByte/migrate/v4/database/stub"
	"github.com/AccelByte/migrate/v4/source"
	_ "github.com/AccelByte/migrate/v4/source/file"
)

func TestSetSourceVarsUnsupportedDriver(t *testing.T) {
	// Unlike an unsupported profile this must be fatal, not advisory:
	// silently skipping expansion ships literal {{ … }} to the database.
	m, err := New("stub://", "stub://")
	if err != nil {
		t.Fatal(err)
	}
	defer func() { _, _ = m.Close() }()

	err = m.SetSourceVars(source.VarConfig{Vars: map[string]string{"A": "1"}})
	if !errors.Is(err, ErrSourceVarsUnsupported) {
		t.Fatalf("SetSourceVars = %v, want ErrSourceVarsUnsupported", err)
	}
}

func TestSetSourceVarsThroughNewWithDatabaseInstance(t *testing.T) {
	// The shape the in-process integration uses: the constructor opens the
	// source itself, and both mutators are available on the returned value.
	dir := t.TempDir()
	write := func(name, body string) {
		t.Helper()
		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil {
			t.Fatal(err)
		}
	}
	write("migrate.vars.json", `{"version": 1, "vars": [
	  {"name": "NAMESPACE", "pattern": "^[a-z]+$"},
	  {"name": "TTL_SECONDS", "default": "604800"}
	]}`)
	write("1_init.up.json", `{"create": "{{ .NAMESPACE }}_users", "ttl": {{ .TTL_SECONDS }}}`)
	write("1_init.sharded.up.json", `{"create": "{{ .NAMESPACE }}_users_sharded"}`)

	m, err := New("file://"+dir, "stub://")
	if err != nil {
		t.Fatal(err)
	}
	defer func() { _, _ = m.Close() }()

	// Order matters: the profile selects the file set variables are
	// validated against.
	if !m.SetSourceProfile("sharded") {
		t.Fatal("SetSourceProfile returned false")
	}
	if err := m.SetSourceVars(source.VarConfig{Vars: map[string]string{"NAMESPACE": "acme"}}); err != nil {
		t.Fatalf("SetSourceVars: %v", err)
	}

	r, _, err := m.sourceDrv.ReadUp(1)
	if err != nil {
		t.Fatalf("ReadUp: %v", err)
	}
	defer func() { _ = r.Close() }()
	body, err := io.ReadAll(r)
	if err != nil {
		t.Fatal(err)
	}
	if want := `{"create": "acme_users_sharded"}`; string(body) != want {
		t.Errorf("ReadUp = %q, want %q", body, want)
	}
}

// TestVarsEndToEndThroughUp is the only test that exercises the whole
// pipeline: SetSourceVars, prefetch, and the database driver. It asserts what
// actually reaches the database, which no source-level test can.
func TestVarsEndToEndThroughUp(t *testing.T) {
	dir := t.TempDir()
	write := func(name, body string) {
		t.Helper()
		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil {
			t.Fatal(err)
		}
	}
	write("migrate.vars.json", `{"version": 1, "vars": [
	  {"name": "NAMESPACE", "pattern": "^[a-z]+$"},
	  {"name": "TTL_SECONDS", "default": "604800", "pattern": "^[0-9]+$"}
	]}`)
	write("1_init.up.sql", "CREATE TABLE {{ .NAMESPACE }}_users (id INT);")
	write("1_init.down.sql", "DROP TABLE {{ .NAMESPACE }}_users;")
	write("2_ttl.up.sql", "ALTER TABLE {{ .NAMESPACE }}_users SET TTL {{ .TTL_SECONDS }};")
	// An empty body must render to an empty body, not fail.
	write("3_noop.up.sql", "")

	m, err := New("file://"+dir, "stub://")
	if err != nil {
		t.Fatal(err)
	}
	defer func() { _, _ = m.Close() }()

	logged := &captureLog{}
	m.Log = logged

	if err := m.SetSourceVars(source.VarConfig{Vars: map[string]string{"NAMESPACE": "acme"}}); err != nil {
		t.Fatalf("SetSourceVars: %v", err)
	}
	if err := m.Up(); err != nil {
		t.Fatalf("Up: %v", err)
	}

	dbDrv := m.databaseDrv.(*dStub.Stub)
	want := []string{
		"CREATE TABLE acme_users (id INT);",
		"ALTER TABLE acme_users SET TTL 604800;",
		"",
	}
	if !reflect.DeepEqual(dbDrv.MigrationSequence, want) {
		t.Errorf("statements reaching the database =\n%q\nwant\n%q", dbDrv.MigrationSequence, want)
	}

	// Expansion adds no log output of its own. Values come from deploy
	// config, versioned alongside the deploy, so a render log would restate
	// what is already recorded — and put secrets in log streams.
	for _, banned := range []string{"variable", "expansion", "acme", "{{"} {
		if strings.Contains(logged.String(), banned) {
			t.Errorf("log mentions %q; expansion should be silent:\n%s", banned, logged.String())
		}
	}

	// Down renders too, from the same validated templates.
	if err := m.Down(); err != nil {
		t.Fatalf("Down: %v", err)
	}
	if got := dbDrv.MigrationSequence[len(dbDrv.MigrationSequence)-1]; got != "DROP TABLE acme_users;" {
		t.Errorf("last down statement = %q", got)
	}
}

// captureLog collects everything migrate logs. It is mutex-guarded because
// migrate logs from the prefetch goroutine as well as the caller's, which is
// why migrate.Logger implementations must be safe for concurrent use.
type captureLog struct {
	mu sync.Mutex
	b  strings.Builder
}

func (l *captureLog) Printf(format string, v ...interface{}) {
	l.mu.Lock()
	defer l.mu.Unlock()
	fmt.Fprintf(&l.b, format, v...)
}

func (l *captureLog) Verbose() bool { return true }

func (l *captureLog) String() string {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.b.String()
}

func TestSetSourceVarsNoManifestIsTheSentinel(t *testing.T) {
	dir := t.TempDir()
	if err := os.WriteFile(filepath.Join(dir, "1_init.up.sql"), []byte("SELECT 1;"), 0o600); err != nil {
		t.Fatal(err)
	}

	m, err := New("file://"+dir, "stub://")
	if err != nil {
		t.Fatal(err)
	}
	defer func() { _, _ = m.Close() }()

	if err := m.SetSourceVars(source.VarConfig{}); !errors.Is(err, source.ErrNoManifest) {
		t.Fatalf("SetSourceVars = %v, want source.ErrNoManifest", err)
	}
}