Skip to content

Modern Docker Management, Designed for Everyone

19.7 KB
Raw Blame
package projects

import (
	"errors"
	"os"
	"path/filepath"
	"runtime"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
)

func TestLoadEnvironment(t *testing.T) {
	// Setup temp dirs
	tmpDir := t.TempDir()
	projectsDir := filepath.Join(tmpDir, "projects")
	workdir := filepath.Join(projectsDir, "myproject")

	err := os.MkdirAll(workdir, utils.DirPerm)
	require.NoError(t, err)

	// Create .env.global
	globalEnvContent := "GLOBAL_VAR=global_value\nSHARED_VAR=global_shared"
	err = os.WriteFile(filepath.Join(projectsDir, ".env.global"), []byte(globalEnvContent), utils.FilePerm)
	require.NoError(t, err)

	// Create .env
	projectEnvContent := "PROJECT_VAR=project_value\nSHARED_VAR=project_shared"
	err = os.WriteFile(filepath.Join(workdir, ".env"), []byte(projectEnvContent), utils.FilePerm)
	require.NoError(t, err)

	t.Run("AutoInjectEnv=false", func(t *testing.T) {
		loader := NewEnvLoader(projectsDir, workdir, false)
		ctx := t.Context()

		envMap, injectionVars, loadEnvironmentErr := loader.LoadEnvironment(ctx)
		require.NoError(t, loadEnvironmentErr)

		// Verify envMap (should contain all vars, project overrides global)
		assert.Equal(t, "global_value", envMap["GLOBAL_VAR"])
		assert.Equal(t, "project_value", envMap["PROJECT_VAR"])
		assert.Equal(t, "project_shared", envMap["SHARED_VAR"])

		// Verify injectionVars (should ONLY contain global vars)
		assert.Equal(t, "global_value", injectionVars["GLOBAL_VAR"])
		assert.Equal(t, "global_shared", injectionVars["SHARED_VAR"])

		_, projectVarInInjection := injectionVars["PROJECT_VAR"]
		assert.False(t, projectVarInInjection, "Project variable should not be in injectionVars")
	})

	t.Run("AutoInjectEnv=true", func(t *testing.T) {
		loader := NewEnvLoader(projectsDir, workdir, true)
		ctx := t.Context()

		envMap, injectionVars, loadEnvironmentErr := loader.LoadEnvironment(ctx)
		require.NoError(t, loadEnvironmentErr)

		// Verify envMap
		assert.Equal(t, "global_value", envMap["GLOBAL_VAR"])
		assert.Equal(t, "project_value", envMap["PROJECT_VAR"])
		assert.Equal(t, "project_shared", envMap["SHARED_VAR"])

		// Verify injectionVars (should contain both global and project vars)
		assert.Equal(t, "global_value", injectionVars["GLOBAL_VAR"])
		assert.Equal(t, "project_value", injectionVars["PROJECT_VAR"])
		assert.Equal(t, "project_shared", injectionVars["SHARED_VAR"])
	})
}

func TestLoadEnvironment_DoesNotCreateMissingGlobalEnvFile(t *testing.T) {
	tmpDir := t.TempDir()
	projectsDir := filepath.Join(tmpDir, "projects")
	workdir := filepath.Join(projectsDir, "myproject")

	require.NoError(t, os.MkdirAll(workdir, utils.DirPerm))
	require.NoError(t, os.WriteFile(filepath.Join(workdir, ".env"), []byte("PROJECT_VAR=project_value\n"), utils.FilePerm))

	loader := NewEnvLoader(projectsDir, workdir, false)
	ctx := t.Context()

	envMap, injectionVars, err := loader.LoadEnvironment(ctx)
	require.NoError(t, err)

	assert.Equal(t, "project_value", envMap["PROJECT_VAR"])
	assert.Empty(t, injectionVars)

	_, statErr := os.Stat(filepath.Join(projectsDir, GlobalEnvFileName))
	assert.ErrorIs(t, statErr, os.ErrNotExist)
}

func TestWithTransientValidationEnvFile_PreservesExternalSymlink(t *testing.T) {
	projectDir := t.TempDir()
	targetPath := filepath.Join(t.TempDir(), "project.env")
	originalContent := "VALUE=original\n"
	targetPerm := os.FileMode(0o640)
	require.NoError(t, os.WriteFile(targetPath, []byte(originalContent), targetPerm))
	require.NoError(t, os.Chmod(targetPath, targetPerm))

	envPath := filepath.Join(projectDir, EffectiveEnvFileName)
	if err := os.Symlink(targetPath, envPath); err != nil {
		t.Skipf("symlink creation is unavailable: %v", err)
	}
	originalLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)

	validationErr := errors.New("validation failed")
	updatedContent := "VALUE=validation\n"
	err = WithTransientValidationEnvFile(t.Context(), projectDir, &updatedContent, func() error {
		content, readErr := os.ReadFile(targetPath)
		require.NoError(t, readErr)
		assert.Equal(t, updatedContent, string(content))

		linkInfo, statErr := os.Lstat(envPath)
		require.NoError(t, statErr)
		require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
		return validationErr
	})
	require.ErrorIs(t, err, validationErr)

	restoredContent, err := os.ReadFile(targetPath)
	require.NoError(t, err)
	assert.Equal(t, originalContent, string(restoredContent))
	currentLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)
	assert.Equal(t, originalLinkTarget, currentLinkTarget)
	if runtime.GOOS != "windows" {
		targetInfo, statErr := os.Stat(targetPath)
		require.NoError(t, statErr)
		assert.Equal(t, targetPerm, targetInfo.Mode().Perm())
	}
}

func TestBuildEffectiveEnvContent(t *testing.T) {
	tests := []struct {
		name            string
		gitContent      string
		overrideContent string
		want            string
		wantEnv         EnvMap
	}{
		{
			name:       "preserves escaped dollar secret exactly",
			gitContent: "CLOUDFLARE_CLIENT_SECRET=$$pbkdf2-sha512$$310000$$XXX\n",
			want:       "CLOUDFLARE_CLIENT_SECRET=$$pbkdf2-sha512$$310000$$XXX\n",
			wantEnv:    EnvMap{"CLOUDFLARE_CLIENT_SECRET": "$pbkdf2-sha512$310000$XXX"},
		},
		{
			name:       "preserves single quoted dollar secret exactly",
			gitContent: "CLOUDFLARE_CLIENT_SECRET='$pbkdf2-sha512$310000$XXX'",
			want:       "CLOUDFLARE_CLIENT_SECRET='$pbkdf2-sha512$310000$XXX'",
			wantEnv:    EnvMap{"CLOUDFLARE_CLIENT_SECRET": "$pbkdf2-sha512$310000$XXX"},
		},
		{
			name:       "preserves comments ordering blank lines bom and crlf",
			gitContent: "\ufeff# keep this comment\r\nZ_LAST=last\r\n\r\nA_FIRST=first",
			want:       "\ufeff# keep this comment\r\nZ_LAST=last\r\n\r\nA_FIRST=first",
			wantEnv:    EnvMap{"Z_LAST": "last", "A_FIRST": "first"},
		},
		{
			name:            "rewrites shared keys in place and appends override-only keys",
			gitContent:      "BASE_URL=https://example.com\nSHARED=git",
			overrideContent: "# local values\nAPI_TOKEN=secret\nSHARED=override\n",
			want:            "BASE_URL=https://example.com\nSHARED=override\n# local values\nAPI_TOKEN=secret\n",
			wantEnv: EnvMap{
				"BASE_URL":  "https://example.com",
				"API_TOKEN": "secret",
				"SHARED":    "override",
			},
		},
		{
			name:            "updates overridden value in place preserving inline comment",
			gitContent:      "PORT=3001 # Port to run the server on\n",
			overrideContent: "PORT=3011\n",
			want:            "PORT=3011 # Port to run the server on\n",
			wantEnv:         EnvMap{"PORT": "3011"},
		},
		{
			name:            "falls back to appending when the git line cannot be rewritten safely",
			gitContent:      "MULTI=\"line1\nline2\"\nOTHER=1\n",
			overrideContent: "MULTI=replaced\n",
			want:            "MULTI=\"line1\nline2\"\nOTHER=1\nMULTI=replaced\n",
			wantEnv:         EnvMap{"MULTI": "replaced", "OTHER": "1"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			effective, err := BuildEffectiveEnvContent(tt.gitContent, tt.overrideContent)
			require.NoError(t, err)
			assert.Equal(t, tt.want, effective)

			parsed, err := ParseProjectEnvContent(effective, nil)
			require.NoError(t, err)
			assert.Equal(t, tt.wantEnv, parsed)
		})
	}
}

func TestBuildOverrideEnvContent(t *testing.T) {
	t.Run("includes only values that differ from git", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\nSHARED=git\n"
		effectiveContent := "BASE_URL=https://example.com\nSHARED=git\nAPI_TOKEN=secret\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Equal(t, "API_TOKEN=secret\n", override)
	})

	t.Run("falls back to git for removed git variables", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\nREMOVE_ME=1\n"
		effectiveContent := "BASE_URL=https://example.com\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Empty(t, override)
	})

	t.Run("drops empty overrides for git-backed keys during normalization", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\nREMOVE_ME=1\n"
		effectiveContent := "BASE_URL=https://example.com\nREMOVE_ME=\nTOKEN=local\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Equal(t, "TOKEN=local\n", override)
	})

	t.Run("keeps explicit empty local-only values", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\n"
		effectiveContent := "BASE_URL=https://example.com\nLOCAL_EMPTY=\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Equal(t, "LOCAL_EMPTY=\n", override)
	})

	t.Run("override derivation keeps local-only keys during migration", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\nREMOTE_ONLY=1\n"
		effectiveContent := "BASE_URL=https://example.com\nTOKEN=local\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Equal(t, "TOKEN=local\n", override)
	})

	t.Run("additive migration keeps only local-only keys when a direct env becomes git-managed", func(t *testing.T) {
		gitContent := "TOKEN=git\nREMOTE_ONLY=1\n"
		localContent := "TOKEN=stale-local\nLOCAL_ONLY=1\n"

		override, err := BuildAdditiveOverrideEnvContent(gitContent, localContent)
		require.NoError(t, err)
		assert.Equal(t, "LOCAL_ONLY=1\n", override)
	})

	t.Run("preserves an existing valid override verbatim", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\n"
		overrideContent := "# keep local formatting\nTOKEN='$pbkdf2-sha512$310000$XXX'\n"

		override, err := BuildOverrideEnvContent(gitContent, overrideContent)
		require.NoError(t, err)
		assert.Equal(t, overrideContent, override)
	})

	t.Run("generated overrides escape literal dollars", func(t *testing.T) {
		gitContent := "BASE_URL=https://example.com\n"
		effectiveContent := "BASE_URL=https://example.com\nTOKEN='$pbkdf2-sha512$310000$XXX'\n"

		override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
		require.NoError(t, err)
		assert.Equal(t, "TOKEN=$$pbkdf2-sha512$$310000$$XXX\n", override)

		parsed, err := ParseProjectEnvContent(override, nil)
		require.NoError(t, err)
		assert.Equal(t, "$pbkdf2-sha512$310000$XXX", parsed["TOKEN"])
	})
}

func TestFormatEnvMapInternal_RoundTripsValues(t *testing.T) {
	values := []string{
		"$pbkdf2-sha512$310000$XXX",
		"prefix $VALUE with spaces",
		`quote " and apostrophe '`,
		`backslash\$VALUE`,
		"line one\nline two",
		"$$literal-dollars",
	}

	for _, value := range values {
		t.Run(value, func(t *testing.T) {
			content := formatEnvMapInternal(EnvMap{"VALUE": value})
			parsed, err := ParseProjectEnvContent(content, nil)
			require.NoError(t, err)
			assert.Equal(t, value, parsed["VALUE"])
		})
	}
}

func TestReadProjectEnvState(t *testing.T) {
	t.Run("direct mode uses .env as editable source", func(t *testing.T) {
		projectDir := t.TempDir()
		require.NoError(t, os.WriteFile(filepath.Join(projectDir, EffectiveEnvFileName), []byte("FOO=bar\n"), utils.FilePerm))

		state, err := ReadProjectEnvState(projectDir)
		require.NoError(t, err)
		assert.Equal(t, ProjectEnvModeDirect, state.Mode)
		assert.Equal(t, EffectiveEnvFileName, state.EditableFileName)
		assert.Equal(t, "FOO=bar\n", state.EditableContent)
		assert.False(t, state.HasGitSource)
		assert.False(t, state.HasOverride)
	})

	t.Run("override mode exposes project.env and git source separately", func(t *testing.T) {
		projectDir := t.TempDir()
		require.NoError(t, os.WriteFile(filepath.Join(projectDir, EffectiveEnvFileName), []byte("A=1\nB=2\n"), utils.FilePerm))
		require.NoError(t, os.WriteFile(filepath.Join(projectDir, GitSourceEnvFileName), []byte("A=1\n"), utils.FilePerm))
		require.NoError(t, os.WriteFile(filepath.Join(projectDir, OverrideEnvFileName), []byte("B=2\n"), utils.FilePerm))

		state, err := ReadProjectEnvState(projectDir)
		require.NoError(t, err)
		assert.Equal(t, ProjectEnvModeOverride, state.Mode)
		assert.Equal(t, OverrideEnvFileName, state.EditableFileName)
		assert.Equal(t, "B=2\n", state.EditableContent)
		assert.True(t, state.HasGitSource)
		assert.Equal(t, "A=1\n", state.GitContent)
		assert.True(t, state.HasOverride)
		assert.Equal(t, "A=1\nB=2\n", state.EffectiveContent)
	})
}

func TestParseComposeEnvOptions(t *testing.T) {
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "sub"), 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "sub", "extra.yml"), []byte("services: {}\n"), 0o600))

	t.Run("scalars, profiles split, and custom separator", func(t *testing.T) {
		t.Parallel()
		env := EnvMap{
			"COMPOSE_FILE":           "base.yml;sub/extra.yml",
			"COMPOSE_PATH_SEPARATOR": ";",
			"COMPOSE_PROFILES":       "frontend, debug",
			"COMPOSE_PROJECT_NAME":   "myproj",
			"COMPOSE_REMOVE_ORPHANS": "true",
			"COMPOSE_IGNORE_ORPHANS": "1",
			"COMPOSE_PARALLEL_LIMIT": "4",
		}

		opts, err := ParseComposeEnvOptions(dir, env)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml"), filepath.Join(dir, "sub", "extra.yml")}, opts.ConfigFiles)
		assert.Equal(t, []string{"frontend", "debug"}, opts.Profiles)
		assert.Equal(t, "myproj", opts.ProjectName)
		assert.True(t, opts.RemoveOrphans)
		assert.True(t, opts.IgnoreOrphans)
		assert.Equal(t, 4, opts.ParallelLimit)
	})

	t.Run("invalid scalars are ignored", func(t *testing.T) {
		t.Parallel()
		opts, err := ParseComposeEnvOptions(dir, EnvMap{
			"COMPOSE_REMOVE_ORPHANS": "nope",
			"COMPOSE_PARALLEL_LIMIT": "-3",
		})
		require.NoError(t, err)
		assert.False(t, opts.RemoveOrphans)
		assert.Zero(t, opts.ParallelLimit)
	})

	t.Run("COMPOSE_ENV_FILES resolved in order, traversal rejected", func(t *testing.T) {
		t.Parallel()
		opts, err := ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_ENV_FILES": "sub/extra.env, .env.local"})
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "sub", "extra.env"), filepath.Join(dir, ".env.local")}, opts.EnvFiles)

		_, err = ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_ENV_FILES": "../outside.env"})
		require.Error(t, err)
		assert.ErrorIs(t, err, common.ErrComposeFileEnvInvalid)
	})

	t.Run("absolute entry rejected", func(t *testing.T) {
		t.Parallel()
		_, err := ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_FILE": filepath.Join(dir, "base.yml")})
		require.Error(t, err)
		assert.ErrorIs(t, err, common.ErrComposeFileEnvInvalid)
	})

	t.Run("escaping entry rejected", func(t *testing.T) {
		t.Parallel()
		_, err := ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_FILE": "../base.yml"})
		require.Error(t, err)
		assert.ErrorIs(t, err, common.ErrComposeFileEnvInvalid)
	})

	t.Run("non-root first entry rejected", func(t *testing.T) {
		t.Parallel()
		_, err := ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_FILE": "sub/extra.yml:base.yml"})
		require.Error(t, err)
		assert.ErrorIs(t, err, common.ErrComposeFileEnvInvalid)
	})

	t.Run("missing entry rejected", func(t *testing.T) {
		t.Parallel()
		_, err := ParseComposeEnvOptions(dir, EnvMap{"COMPOSE_FILE": "base.yml:sub/missing.yml"})
		require.Error(t, err)
		assert.ErrorIs(t, err, common.ErrComposeFileEnvInvalid)
	})
}

func TestComposeFileEnvSelection(t *testing.T) {
	t.Parallel()

	t.Run("nil when no .env", func(t *testing.T) {
		t.Parallel()
		files, err := ComposeFileEnvSelection(t.Context(), "", t.TempDir())
		require.NoError(t, err)
		assert.Nil(t, files)
	})

	t.Run("resolves COMPOSE_FILE from .env", func(t *testing.T) {
		t.Parallel()
		dir := t.TempDir()
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "extra.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=base.yml:extra.yml\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), "", dir)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml"), filepath.Join(dir, "extra.yml")}, files)
	})

	t.Run("resolves COMPOSE_FILE from COMPOSE_ENV_FILES entry", func(t *testing.T) {
		t.Parallel()
		dir := t.TempDir()
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "aux.env"), []byte("COMPOSE_FILE=base.yml\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_ENV_FILES=aux.env\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), "", dir)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml")}, files)
	})

	t.Run("global COMPOSE_DISABLE_ENV_FILE skips project .env", func(t *testing.T) {
		t.Parallel()
		projectsDir := t.TempDir()
		dir := filepath.Join(projectsDir, "proj")
		require.NoError(t, os.MkdirAll(dir, 0o755))
		require.NoError(t, os.WriteFile(filepath.Join(projectsDir, GlobalEnvFileName), []byte("COMPOSE_DISABLE_ENV_FILE=true\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=base.yml\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), projectsDir, dir)
		require.NoError(t, err)
		assert.Nil(t, files)
	})

	t.Run("global COMPOSE_FILE selects the base when the project .env is silent", func(t *testing.T) {
		t.Parallel()
		projectsDir := t.TempDir()
		dir := filepath.Join(projectsDir, "proj")
		require.NoError(t, os.MkdirAll(dir, 0o755))
		require.NoError(t, os.WriteFile(filepath.Join(projectsDir, GlobalEnvFileName), []byte("COMPOSE_FILE=base.yml\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), projectsDir, dir)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml")}, files)
	})

	t.Run("project .env COMPOSE_FILE overrides the global value", func(t *testing.T) {
		t.Parallel()
		projectsDir := t.TempDir()
		dir := filepath.Join(projectsDir, "proj")
		require.NoError(t, os.MkdirAll(dir, 0o755))
		require.NoError(t, os.WriteFile(filepath.Join(projectsDir, GlobalEnvFileName), []byte("COMPOSE_FILE=global.yml\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "global.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=base.yml\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), projectsDir, dir)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml")}, files)
	})

	t.Run("COMPOSE_DISABLE_ENV_FILE still honors a global COMPOSE_FILE", func(t *testing.T) {
		t.Parallel()
		projectsDir := t.TempDir()
		dir := filepath.Join(projectsDir, "proj")
		require.NoError(t, os.MkdirAll(dir, 0o755))
		require.NoError(t, os.WriteFile(filepath.Join(projectsDir, GlobalEnvFileName), []byte("COMPOSE_DISABLE_ENV_FILE=true\nCOMPOSE_FILE=base.yml\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "base.yml"), []byte("services: {}\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=other.yml\n"), 0o600))

		files, err := ComposeFileEnvSelection(t.Context(), projectsDir, dir)
		require.NoError(t, err)
		assert.Equal(t, []string{filepath.Join(dir, "base.yml")}, files)
	})
}

func TestEnvContentChanged(t *testing.T) {
	t.Run("ignores formatting-only changes", func(t *testing.T) {
		oldEnv := "B=2\nA=1\n# comment\n"
		newEnv := "A=1\nB=2\n"

		assert.False(t, EnvContentChanged(oldEnv, newEnv))
	})

	t.Run("detects semantic changes", func(t *testing.T) {
		oldEnv := "A=1\nB=2\n"
		newEnv := "A=1\nB=3\n"

		assert.True(t, EnvContentChanged(oldEnv, newEnv))
	})
}