integration_test.go

package main

import (
	"context"
	"os"
	"path/filepath"
	"reflect"
	"slices"
	"strings"
	"testing"
	"time"
)

// requireAllVar, when set (as in CI), makes a missing Visual Studio or shell a
// test failure rather than a skip.
const requireAllVar = "VSENV_TEST_REQUIRE_ALL"

// missingf skips the test for something it needs that's missing, or fails it
// if requireAllVar is set.
func missingf(t *testing.T, format string, args ...any) {
	t.Helper()
	if os.Getenv(requireAllVar) != "" {
		t.Fatalf(format, args...)
	}
	t.Skipf(format, args...)
}

// otherArch returns a second target architecture to test besides arch: x86
// on x64, as the default C++ workload installs both, and x64 elsewhere.
func otherArch(arch string) string {
	if arch == archX64 {
		return archX86
	}
	return archX64
}

func requireVS(t *testing.T) {
	t.Helper()
	if _, err := os.Stat(vswhereDefault); err != nil {
		missingf(t, "vswhere not installed at %s", vswhereDefault)
	}
}

func TestIntegration_RunVsWhere(t *testing.T) {
	requireVS(t)
	installs, err := runVsWhere(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if len(installs) == 0 {
		missingf(t, "no VS installations")
	}
	for _, i := range installs {
		if i.InstanceID == "" {
			t.Errorf("entry missing instanceId: %+v", i)
		}
		if i.InstallationPath == "" {
			t.Errorf("entry missing installationPath: %+v", i)
		}
		if i.InstallationVersion == "" {
			t.Errorf("entry missing installationVersion: %+v", i)
		}
		if _, statErr := os.Stat(i.InstallationPath); statErr != nil {
			t.Errorf("installationPath does not exist: %s", i.InstallationPath)
		}
	}
}

func TestIntegration_DiscoverInstalls_WritesCache(t *testing.T) {
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())

	a, err := DiscoverInstalls(context.Background(), false)
	if err != nil {
		t.Fatal(err)
	}
	if len(a) == 0 {
		missingf(t, "no VS installs")
	}

	cachePath, err := installsCachePath()
	if err != nil {
		t.Fatal(err)
	}
	if _, statErr := os.Stat(cachePath); statErr != nil {
		t.Errorf("expected cache file written: %v", statErr)
	}

	// Second call should hit cache. Check by removing vswhere from PATH
	// — actually we can't easily; just verify equivalence.
	b, err := DiscoverInstalls(context.Background(), false)
	if err != nil {
		t.Fatal(err)
	}
	if len(a) != len(b) {
		t.Errorf("cached result differs: %d vs %d", len(a), len(b))
	}
}

func TestIntegration_DiscoverInstalls_ForceRefresh(t *testing.T) {
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())

	if _, err := DiscoverInstalls(context.Background(), false); err != nil {
		t.Fatal(err)
	}

	// Force refresh should re-run vswhere even if cache exists
	if _, err := DiscoverInstalls(context.Background(), true); err != nil {
		t.Fatal(err)
	}
}

func TestIntegration_CaptureDevShellEnv(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping VsDevCmd.bat run in short mode")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	env, err := captureDevShellEnv(context.Background(), install, nativeArch(), nativeArch(), "", baseEnv())
	if err != nil {
		t.Fatal(err)
	}

	requiredKeys := []string{"VSINSTALLDIR", "VCINSTALLDIR", "INCLUDE", "LIB", "PATH", "VSCMD_VER"}
	for _, k := range requiredKeys {
		if lookupFold(env, k) == "" {
			t.Errorf("missing expected env var %s in VsDevCmd output", k)
		}
	}

	if v := env["VSCMD_ARG_TGT_ARCH"]; v != nativeArch() {
		t.Errorf("VSCMD_ARG_TGT_ARCH = %q, want %s", v, nativeArch())
	}

	for _, k := range []string{telemetryOptOut, devCmdVar, devCmdArgsVar, selfVar} {
		if _, leaked := env[k]; leaked {
			t.Errorf("%s leaked into the captured env", k)
		}
	}
}

// Only catches a regression where the console code page isn't UTF-8, which
// is the default.
func TestIntegration_CaptureDevShellEnv_NonASCII(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping VsDevCmd.bat run in short mode")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	const value, entry = "José Олег 日本", `C:\Users\José\bin`
	base := append(baseEnv(), "VSENV_TEST_NON_ASCII="+value)
	for i, kv := range base {
		if k, v, _ := strings.Cut(kv, "="); strings.EqualFold(k, "PATH") {
			base[i] = k + "=" + entry + ";" + v
		}
	}
	full, err := captureDevShellEnv(context.Background(), install, nativeArch(), nativeArch(), "", base)
	if err != nil {
		t.Fatal(err)
	}
	if got := full["VSENV_TEST_NON_ASCII"]; got != value {
		t.Errorf("VSENV_TEST_NON_ASCII = %q, want %q", got, value)
	}
	diff := diffEnv(envMap(base), full)
	if _, ok := diff.Vars["VSENV_TEST_NON_ASCII"]; ok {
		t.Error("an unchanged non-ASCII variable is in the diff")
	}
	// Garbled, the original PATH isn't found in VsDevCmd's, so its entries
	// end up among the VS ones.
	if slices.ContainsFunc(diff.PathBefore, func(p string) bool { return strings.Contains(p, `\Users\Jos`) }) {
		t.Errorf("an original PATH entry is among the VS ones: %q", diff.PathBefore)
	}
}

func TestIntegration_CaptureDevShellEnv_LongValue(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping VsDevCmd.bat run in short mode")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	value := strings.Repeat("x", 30000)
	base := append(baseEnv(), "VSENV_TEST_LONG="+value)
	full, err := captureDevShellEnv(context.Background(), install, nativeArch(), nativeArch(), "", base)
	if err != nil {
		t.Fatal(err)
	}
	if got := full["VSENV_TEST_LONG"]; got != value {
		t.Errorf("VSENV_TEST_LONG came back %d characters long, want %d", len(got), len(value))
	}
	if _, ok := diffEnv(envMap(base), full).Vars["VSENV_TEST_LONG"]; ok {
		t.Error("an unchanged long variable is in the diff")
	}
}

// captureDevEnv relies on VsDevCmd.bat adding the same with minimalPath.
func TestIntegration_CaptureDevShellEnv_MinimalPath(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping (slow: runs VsDevCmd four times)")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	base := baseEnv()
	minimal := withPath(base, minimalPath(base))
	for _, arch := range []string{nativeArch(), otherArch(nativeArch())} {
		var diffs []devEnv
		for _, b := range [][]string{base, minimal} {
			full, captureErr := captureDevShellEnv(context.Background(), install, arch, nativeArch(), "", b)
			if captureErr != nil {
				t.Fatalf("%s: %v", arch, captureErr)
			}
			diffs = append(diffs, diffEnv(envMap(b), full))
		}
		if !reflect.DeepEqual(diffs[0], diffs[1]) {
			t.Errorf("%s: VsDevCmd.bat adds\n%+v\nwith the default PATH, and\n%+v\nwith a minimal one",
				arch, diffs[0], diffs[1])
		}
	}
}

// VsDevCmd.bat fails with a PATH of about 7000 characters, and leaves out the
// SDK with one over maxCmdPath.
func TestIntegration_CaptureDevEnv_LongPath(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping (slow: runs VsDevCmd three times)")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	base := baseEnv()
	path := lookupFold(envMap(base), "PATH")
	for _, n := range []int{7000, 9000} {
		long := strings.Repeat(`C:\pad;`, (n-len(path))/len(`C:\pad;`)+1) + path
		diff, captureErr := captureDevEnv(context.Background(), install, nativeArch(), nativeArch(), "",
			withPath(base, long))
		if captureErr != nil {
			t.Fatalf("a PATH of %d characters: %v", len(long), captureErr)
		}
		if !slices.ContainsFunc(diff.PathBefore, func(p string) bool {
			return strings.Contains(strings.ToLower(p), `\vc\tools\msvc\`)
		}) {
			t.Errorf("a PATH of %d characters: PathBefore lacks the MSVC bin dir: %q", len(long), diff.PathBefore)
		}
		if !slices.ContainsFunc(diff.Lists["LIB"].Before, func(p string) bool {
			return strings.Contains(strings.ToLower(p), `\windows kits\`)
		}) {
			t.Errorf("a PATH of %d characters: LIB lacks the Windows SDK: %q", len(long), diff.Lists["LIB"].Before)
		}
	}
}

// sdkStateTime finds the SDK that VsDevCmd.bat uses.
func TestIntegration_SDKStateTime(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping VsDevCmd.bat run in short mode")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())
	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}
	env, err := captureDevShellEnv(context.Background(), install, nativeArch(), nativeArch(), "", baseEnv())
	if err != nil {
		t.Fatal(err)
	}
	sdk := lookupFold(env, "WindowsSdkDir")
	if sdk == "" {
		missingf(t, "no Windows SDK")
	}
	info, err := os.Stat(filepath.Join(sdk, "Include"))
	if err != nil {
		t.Fatal(err)
	}
	if got := sdkStateTime(); !got.Equal(info.ModTime()) {
		t.Errorf("sdkStateTime() = %v, want %v, %s's", got, info.ModTime(), sdk)
	}
}

func TestIntegration_GetEnv_FromLoadedShell(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping (slow: runs VsDevCmd twice)")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())

	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}
	clean, err := GetEnv(context.Background(), install, nativeArch(), nativeArch(), "")
	if err != nil {
		t.Fatal(err)
	}

	// Rebuild the cache from a process that already has the VS environment,
	// as after 'vsenv refresh' in a shell whose profile loaded it.
	for _, kv := range mergedEnv(clean) {
		if k, v, ok := strings.Cut(kv, "="); ok && k != "" {
			t.Setenv(k, v)
		}
	}
	if clearErr := ClearEnvCache(); clearErr != nil {
		t.Fatal(clearErr)
	}
	loaded, err := GetEnv(context.Background(), install, nativeArch(), nativeArch(), "")
	if err != nil {
		t.Fatal(err)
	}

	if len(loaded.Vars) != len(clean.Vars) || loaded.Vars["VSINSTALLDIR"] != clean.Vars["VSINSTALLDIR"] {
		t.Errorf("capture depends on the calling shell: %d vars vs %d clean", len(loaded.Vars), len(clean.Vars))
	}
	if !slices.Equal(loaded.PathBefore, clean.PathBefore) || !slices.Equal(loaded.PathAfter, clean.PathAfter) {
		t.Errorf("PATH entries differ:\nloaded %q\nclean  %q", loaded.PathBefore, clean.PathBefore)
	}
	if lib := loaded.Lists["LIB"].Before; len(lib) == 0 || !slices.Equal(lib, clean.Lists["LIB"].Before) {
		t.Errorf("LIB entries differ:\nloaded %q\nclean  %q", lib, clean.Lists["LIB"].Before)
	}
}

func TestIntegration_GetEnv_FullPipeline(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping full pipeline in short mode")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())

	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	// Cold call: should run VsDevCmd.bat
	cold := time.Now()
	env1, err := GetEnv(context.Background(), install, nativeArch(), nativeArch(), "")
	if err != nil {
		t.Fatal(err)
	}
	coldDur := time.Since(cold)

	if v := env1.Vars["VSINSTALLDIR"]; !strings.Contains(strings.ToLower(v), "visual studio") {
		t.Errorf("VSINSTALLDIR doesn't look right: %q", v)
	}
	if !slices.ContainsFunc(env1.PathBefore, func(p string) bool {
		return strings.Contains(strings.ToLower(p), `\vc\tools\msvc\`)
	}) {
		t.Errorf("PathBefore lacks the MSVC bin dir: %q", env1.PathBefore)
	}

	// Warm call: cache hit, must be fast
	warm := time.Now()
	env2, err := GetEnv(context.Background(), install, nativeArch(), nativeArch(), "")
	if err != nil {
		t.Fatal(err)
	}
	warmDur := time.Since(warm)

	if warmDur > 500*time.Millisecond {
		t.Errorf("warm cache took %v (>500ms); cold took %v", warmDur, coldDur)
	}
	if len(env1.Vars) != len(env2.Vars) {
		t.Errorf("cold/warm env size mismatch: %d vs %d", len(env1.Vars), len(env2.Vars))
	}
	for k, v := range env1.Vars {
		if env2.Vars[k] != v {
			t.Errorf("warm cache differs for %s: %q vs %q", k, env2.Vars[k], v)
			break
		}
	}
	if !slices.Equal(env1.PathBefore, env2.PathBefore) || !slices.Equal(env1.PathAfter, env2.PathAfter) {
		t.Error("warm cache PATH entries differ from cold")
	}

	t.Logf("cold: %v, warm: %v, env vars: %d", coldDur, warmDur, len(env1.Vars))
}

func TestIntegration_GetEnv_DifferentArchsCacheSeparately(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping (slow: runs VsDevCmd twice)")
	}
	requireVS(t)
	t.Setenv("LOCALAPPDATA", t.TempDir())

	install, err := SelectInstall(context.Background(), "")
	if err != nil {
		missingf(t, "no install: %v", err)
	}

	native, other := nativeArch(), otherArch(nativeArch())
	envNative, err := GetEnv(context.Background(), install, native, native, "")
	if err != nil {
		t.Fatal(err)
	}
	envOther, err := GetEnv(context.Background(), install, other, native, "")
	if err != nil {
		t.Fatalf("%s capture: %v", other, err)
	}

	if got := envNative.Vars["VSCMD_ARG_TGT_ARCH"]; got != native {
		t.Errorf("%s cache has the target arch %q", native, got)
	}
	if got := envOther.Vars["VSCMD_ARG_TGT_ARCH"]; got != other {
		t.Errorf("%s cache has the target arch %q", other, got)
	}

	// LIB paths should differ between archs
	if a, b := envNative.Lists["LIB"].Before, envOther.Lists["LIB"].Before; len(a) == 0 || slices.Equal(a, b) {
		t.Errorf("LIB entries should differ between %s and %s: %q and %q", native, other, a, b)
	}
}

func TestIntegration_VswhereOutput_HasExpectedFields(t *testing.T) {
	requireVS(t)
	installs, err := runVsWhere(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if len(installs) == 0 {
		missingf(t, "no installs")
	}
	i := installs[0]
	// These four are what we use in cache keys / display.
	if i.InstanceID == "" || i.InstallationPath == "" ||
		i.InstallationVersion == "" || i.DisplayName == "" {
		t.Errorf("vswhere returned an install missing required fields: %+v", i)
	}
}