start_test.go

package start

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"testing"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/network"
	"github.com/docker/docker/api/types/volume"
	"github.com/h2non/gock"
	"github.com/jackc/pgconn"
	"github.com/spf13/afero"
	"github.com/spf13/viper"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/supabase/cli/internal/testing/apitest"
	"github.com/supabase/cli/internal/utils"
	"github.com/supabase/cli/internal/utils/flags"
	"github.com/supabase/cli/pkg/config"
	"github.com/supabase/cli/pkg/pgtest"
	"github.com/supabase/cli/pkg/storage"
)

func TestStartCommand(t *testing.T) {
	t.Run("throws error on missing config", func(t *testing.T) {
		err := Run(context.Background(), afero.NewMemMapFs(), []string{}, false)
		assert.ErrorIs(t, err, os.ErrNotExist)
	})

	t.Run("throws error on invalid config", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		require.NoError(t, afero.WriteFile(fsys, utils.ConfigPath, []byte("malformed"), 0644))
		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		// Check error
		assert.ErrorContains(t, err, "toml: expected = after a key, but the document ends there")
	})

	t.Run("throws error on missing docker", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		require.NoError(t, utils.WriteConfig(fsys, false))
		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))
		defer gock.OffAll()
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers").
			ReplyError(errors.New("network error"))
		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		// Check error
		assert.ErrorContains(t, err, "network error")
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})

	t.Run("show status if database is already running", func(t *testing.T) {
		var running []types.Container
		for _, name := range utils.GetDockerIds() {
			running = append(running, types.Container{
				Names: []string{name + "_test"},
			})
		}
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		require.NoError(t, utils.WriteConfig(fsys, false))
		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))
		defer gock.OffAll()
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers").
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{})

		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/supabase_db_start/json").
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{
				State: &types.ContainerState{Running: true},
			}})
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/json").
			Reply(http.StatusOK).
			JSON(running)
		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		// Check error
		assert.NoError(t, err)
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})

	t.Run("loads custom config path", func(t *testing.T) {
		fsys := afero.NewMemMapFs()
		customPath := filepath.ToSlash("custom/path/config.toml")
		projectId := "test_project"

		// Create directories and required files
		require.NoError(t, fsys.MkdirAll(filepath.Dir(customPath), 0755))
		require.NoError(t, fsys.MkdirAll("supabase", 0755))
		require.NoError(t, afero.WriteFile(fsys, "supabase/seed.sql", []byte(""), 0644))
		require.NoError(t, afero.WriteFile(fsys, "supabase/roles.sql", []byte(""), 0644))

		// Store original values
		originalDbId := utils.DbId
		originalConfigFile := flags.ConfigFile
		originalWorkdir := viper.GetString("WORKDIR")

		t.Cleanup(func() {
			utils.DbId = originalDbId
			flags.ConfigFile = originalConfigFile
			viper.Set("WORKDIR", originalWorkdir)
			gock.Off()
		})

		// Write config file
		require.NoError(t, afero.WriteFile(fsys, customPath, []byte(`
		project_id = "`+projectId+`"
		[db]
		port = 54332
		major_version = 15`), 0644))

		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))

		// Mock container list check
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/json").
			Reply(http.StatusOK).
			JSON([]types.Container{})

		// Mock container health check
		utils.DbId = "supabase_db_" + projectId
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/" + utils.DbId + "/json").
			Times(2).
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{
				ContainerJSONBase: &types.ContainerJSONBase{
					State: &types.ContainerState{
						Running: true,
						Health:  &types.Health{Status: types.Healthy},
					},
				},
			})

		flags.ConfigFile = customPath

		err := Run(context.Background(), fsys, []string{}, false)
		assert.NoError(t, err)
		assert.Equal(t, filepath.ToSlash("custom/path"), viper.GetString("WORKDIR"))
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})

	t.Run("handles absolute config path", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		absPath := "/absolute/path/config.toml"
		projectId := "abs_project"

		// Create directories and required files
		require.NoError(t, fsys.MkdirAll("/absolute/path", 0755))
		require.NoError(t, fsys.MkdirAll("/supabase", 0755))
		require.NoError(t, afero.WriteFile(fsys, "/supabase/seed.sql", []byte(""), 0644))
		require.NoError(t, afero.WriteFile(fsys, "/supabase/roles.sql", []byte(""), 0644))

		// Store original values
		originalDbId := utils.DbId
		originalConfigFile := flags.ConfigFile
		originalWorkdir := viper.GetString("WORKDIR")

		t.Cleanup(func() {
			utils.DbId = originalDbId
			flags.ConfigFile = originalConfigFile
			viper.Set("WORKDIR", originalWorkdir)
			gock.Off()
		})

		// Write config file
		require.NoError(t, afero.WriteFile(fsys, absPath, []byte(`
		project_id = "`+projectId+`"
		[db]
		port = 54332
		major_version = 15`), 0644))

		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))
		defer gock.OffAll()

		// Mock container list check
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/json").
			Reply(http.StatusOK).
			JSON([]types.Container{})

		// Mock container health check
		utils.DbId = "supabase_db_" + projectId
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/" + utils.DbId + "/json").
			Times(2).
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{
				ContainerJSONBase: &types.ContainerJSONBase{
					State: &types.ContainerState{
						Running: true,
						Health:  &types.Health{Status: types.Healthy},
					},
				},
			})

		// Set the custom config path
		flags.ConfigFile = absPath

		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		assert.NoError(t, err)
		assert.Equal(t, "/absolute/path", viper.GetString("WORKDIR"))
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})

	t.Run("handles non-existent config directory", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		nonExistentPath := "non/existent/path/config.toml"

		// Store original values
		originalConfigFile := flags.ConfigFile

		t.Cleanup(func() {
			flags.ConfigFile = originalConfigFile
		})

		// Set the custom config path
		flags.ConfigFile = nonExistentPath

		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		assert.ErrorIs(t, err, os.ErrNotExist)
	})

	t.Run("handles malformed config in custom path", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		customPath := "custom/config.toml"

		// Create directory and malformed config
		require.NoError(t, fsys.MkdirAll("custom", 0755))
		require.NoError(t, afero.WriteFile(fsys, customPath, []byte("malformed toml content"), 0644))

		// Store original values
		originalConfigFile := flags.ConfigFile

		t.Cleanup(func() {
			flags.ConfigFile = originalConfigFile
		})

		// Set the custom config path
		flags.ConfigFile = customPath

		// Run test
		err := Run(context.Background(), fsys, []string{}, false)
		assert.ErrorContains(t, err, "toml: ")
	})
}

func TestDatabaseStart(t *testing.T) {
	t.Run("starts database locally", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))
		defer gock.OffAll()
		gock.New(utils.Docker.DaemonHost()).
			Post("/v" + utils.Docker.ClientVersion() + "/networks/create").
			Reply(http.StatusCreated).
			JSON(network.CreateResponse{})
		// Caches all dependencies
		imageUrl := utils.GetRegistryImageUrl(utils.Config.Db.Image)
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/images/" + imageUrl + "/json").
			Reply(http.StatusOK).
			JSON(types.ImageInspect{})
		for _, image := range config.ServiceImages {
			service := utils.GetRegistryImageUrl(image)
			gock.New(utils.Docker.DaemonHost()).
				Get("/v" + utils.Docker.ClientVersion() + "/images/" + service + "/json").
				Reply(http.StatusOK).
				JSON(types.ImageInspect{})
		}
		// Start postgres
		utils.DbId = "test-postgres"
		utils.ConfigId = "test-config"
		utils.Config.Db.Port = 54322
		utils.Config.Db.MajorVersion = 15
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/volumes/" + utils.DbId).
			Reply(http.StatusNotFound)
		apitest.MockDockerStart(utils.Docker, imageUrl, utils.DbId)
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Realtime.Image), "test-realtime")
		require.NoError(t, apitest.MockDockerLogs(utils.Docker, "test-realtime", ""))
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Storage.Image), "test-storage")
		require.NoError(t, apitest.MockDockerLogs(utils.Docker, "test-storage", ""))
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Auth.Image), "test-auth")
		require.NoError(t, apitest.MockDockerLogs(utils.Docker, "test-auth", ""))
		// Start services
		utils.KongId = "test-kong"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Api.KongImage), utils.KongId)
		utils.GotrueId = "test-gotrue"
		utils.Config.Auth.EnableSignup = true
		utils.Config.Auth.Email.EnableSignup = true
		utils.Config.Auth.Email.DoubleConfirmChanges = true
		utils.Config.Auth.Email.EnableConfirmations = true
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Auth.Image), utils.GotrueId)
		utils.InbucketId = "test-inbucket"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Inbucket.Image), utils.InbucketId)
		utils.RealtimeId = "test-realtime"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Realtime.Image), utils.RealtimeId)
		utils.RestId = "test-rest"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Api.Image), utils.RestId)
		utils.StorageId = "test-storage"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Storage.Image), utils.StorageId)
		utils.ImgProxyId = "test-imgproxy"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Storage.ImgProxyImage), utils.ImgProxyId)
		utils.EdgeRuntimeId = "test-edge-runtime"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.EdgeRuntime.Image), utils.EdgeRuntimeId)
		utils.PgmetaId = "test-pgmeta"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Studio.PgmetaImage), utils.PgmetaId)
		utils.StudioId = "test-studio"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Studio.Image), utils.StudioId)
		utils.LogflareId = "test-logflare"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Analytics.Image), utils.LogflareId)
		utils.VectorId = "test-vector"
		apitest.MockDockerStart(utils.Docker, utils.GetRegistryImageUrl(utils.Config.Analytics.VectorImage), utils.VectorId)
		// Setup mock postgres
		conn := pgtest.NewConn()
		defer conn.Close(t)
		// Setup health probes
		started := []string{
			utils.DbId, utils.KongId, utils.GotrueId, utils.InbucketId, utils.RealtimeId,
			utils.StorageId, utils.ImgProxyId, utils.EdgeRuntimeId, utils.PgmetaId, utils.StudioId,
			utils.LogflareId, utils.RestId, utils.VectorId,
		}
		for _, container := range started {
			gock.New(utils.Docker.DaemonHost()).
				Get("/v" + utils.Docker.ClientVersion() + "/containers/" + container + "/json").
				Reply(http.StatusOK).
				JSON(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{
					State: &types.ContainerState{
						Running: true,
						Health:  &types.Health{Status: types.Healthy},
					},
				}})
		}
		gock.New(utils.Config.Api.ExternalUrl).
			Head("/rest-admin/v1/ready").
			Reply(http.StatusOK)
		gock.New(utils.Config.Api.ExternalUrl).
			Head("/functions/v1/_internal/health").
			Reply(http.StatusOK)
		// Seed tenant services
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/" + utils.StorageId + "/json").
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{
				State: &types.ContainerState{
					Running: true,
					Health:  &types.Health{Status: types.Healthy},
				},
			}})
		gock.New(utils.Config.Api.ExternalUrl).
			Get("/storage/v1/bucket").
			Reply(http.StatusOK).
			JSON([]storage.BucketResponse{})
		// Run test
		err := utils.RunProgram(context.Background(), func(p utils.Program, ctx context.Context) error {
			return run(p, context.Background(), fsys, []string{}, pgconn.Config{Host: utils.DbId}, conn.Intercept)
		})
		// Check error
		assert.NoError(t, err)
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})

	t.Run("skips excluded containers", func(t *testing.T) {
		// Setup in-memory fs
		fsys := afero.NewMemMapFs()
		// Setup mock docker
		require.NoError(t, apitest.MockDocker(utils.Docker))
		defer gock.OffAll()
		gock.New(utils.Docker.DaemonHost()).
			Post("/v" + utils.Docker.ClientVersion() + "/networks/create").
			Reply(http.StatusCreated).
			JSON(network.CreateResponse{})
		// Caches all dependencies
		imageUrl := utils.GetRegistryImageUrl(utils.Config.Db.Image)
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/images/" + imageUrl + "/json").
			Reply(http.StatusOK).
			JSON(types.ImageInspect{})
		// Start postgres
		utils.DbId = "test-postgres"
		utils.ConfigId = "test-config"
		utils.Config.Db.Port = 54322
		utils.Config.Db.MajorVersion = 15
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/volumes/" + utils.DbId).
			Reply(http.StatusOK).
			JSON(volume.Volume{})
		apitest.MockDockerStart(utils.Docker, imageUrl, utils.DbId)
		gock.New(utils.Docker.DaemonHost()).
			Get("/v" + utils.Docker.ClientVersion() + "/containers/" + utils.DbId + "/json").
			Reply(http.StatusOK).
			JSON(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{
				State: &types.ContainerState{
					Running: true,
					Health:  &types.Health{Status: types.Healthy},
				},
			}})
		// Run test
		exclude := ExcludableContainers()
		exclude = append(exclude, "invalid", exclude[0])
		err := utils.RunProgram(context.Background(), func(p utils.Program, ctx context.Context) error {
			return run(p, context.Background(), fsys, exclude, pgconn.Config{Host: utils.DbId})
		})
		// Check error
		assert.NoError(t, err)
		assert.Empty(t, apitest.ListUnmatchedRequests())
	})
}

func TestFormatMapForEnvConfig(t *testing.T) {
	t.Run("It produces the correct format and removes the trailing comma", func(t *testing.T) {
		output := bytes.Buffer{}
		input := map[string]string{}

		keys := [4]string{"123456", "234567", "345678", "456789"}
		values := [4]string{"123456", "234567", "345678", "456789"}
		expected := [4]string{
			`^\w{6}:\w{6}$`,
			`^\w{6}:\w{6},\w{6}:\w{6}$`,
			`^\w{6}:\w{6},\w{6}:\w{6},\w{6}:\w{6}$`,
			`^\w{6}:\w{6},\w{6}:\w{6},\w{6}:\w{6},\w{6}:\w{6}$`,
		}
		formatMapForEnvConfig(input, &output)
		if len(output.Bytes()) > 0 {
			t.Error("No values should be expected when empty map is provided")
		}
		for i := 0; i < 4; i++ {
			output.Reset()
			input[keys[i]] = values[i]
			formatMapForEnvConfig(input, &output)
			result := output.String()
			assert.Regexp(t, regexp.MustCompile(expected[i]), result)
		}
	})
}

// Helper function to reduce duplication
func setupTestConfig(t *testing.T, fsys afero.Fs, configPath, projectId string, isAbsolute bool) {
	// Create directories and required files
	require.NoError(t, fsys.MkdirAll(filepath.Dir(configPath), 0755))
	supabasePath := "supabase"
	if isAbsolute {
		supabasePath = "/supabase"
	}
	require.NoError(t, fsys.MkdirAll(supabasePath, 0755))
	require.NoError(t, afero.WriteFile(fsys, filepath.Join(supabasePath, "seed.sql"), []byte(""), 0644))
	require.NoError(t, afero.WriteFile(fsys, filepath.Join(supabasePath, "roles.sql"), []byte(""), 0644))

	// Write minimal config file
	configContent := fmt.Sprintf(`
	project_id = "%s"
	[db]
	port = 54332
	major_version = 15`, projectId)
	require.NoError(t, afero.WriteFile(fsys, configPath, []byte(configContent), 0644))
}