test

func validatePackagePattern(pkg string) error

{
	if pkg == "." || pkg == "./..." {
		return nil
	}
	if pkg == "" || strings.HasPrefix(pkg, "-") || strings.HasPrefix(pkg, "/") {
		return fmt.Errorf("test package %q is not a package pattern", pkg)
	}
	for _, char := range pkg {
		if unicode.IsSpace(char) || unicode.IsControl(char) {
			return fmt.Errorf("test package %q contains whitespace or control characters", pkg)
		}
		if char >= 'a' && char <= 'z' ||
			char >= 'A' && char <= 'Z' ||
			char >= '0' && char <= '9' ||
			strings.ContainsRune("-_./+", char) {
			continue
		}
		return fmt.Errorf("test package %q contains invalid character %q", pkg, char)
	}
	segments := strings.Split(strings.TrimPrefix(pkg, "./"), "/")
	for index, segment := range segments {
		if segment == "" || segment == "." || segment == ".." {
			return fmt.Errorf("test package %q escapes the project", pkg)
		}
		if segment == "..." && index != len(segments)-1 {
			return fmt.Errorf("test package %q has a non-terminal recursive wildcard", pkg)
		}
	}
	return nil
}

func packageTestCommand(pattern string) (*exec.Cmd, error)

{
	if err := validatePackagePattern(pattern); err != nil {
		return nil, err
	}
	localPattern := pattern
	if pattern != "." && !strings.HasPrefix(pattern, "./") {
		moduleOutput, err := exec.Command("go", "list", "-m").Output()
		if err != nil {
			return nil, fmt.Errorf("resolve project module: %w", err)
		}
		modulePath := strings.TrimSpace(string(moduleOutput))
		switch {
		case pattern == modulePath:
			localPattern = "."
		case strings.HasPrefix(pattern, modulePath+"/"):
			localPattern = "./" + strings.TrimPrefix(pattern, modulePath+"/")
		default:
			return nil, fmt.Errorf("test package %q is outside module %q", pattern, modulePath)
		}
	}
	switch localPattern {
	case ".":
		return exec.Command("go", "test", "."), nil
	case "./...":
		return exec.Command("go", "test", "./..."), nil
	}

	relative := strings.TrimPrefix(localPattern, "./")
	recursive := strings.HasSuffix(relative, "/...")
	relative = strings.TrimSuffix(relative, "/...")
	directory, err := resolveProjectDirectory(relative)
	if err != nil {
		return nil, fmt.Errorf("test package %q: %w", pattern, err)
	}

	var cmd *exec.Cmd
	if recursive {
		cmd = exec.Command("go", "test", "./...")
	} else {
		cmd = exec.Command("go", "test", ".")
	}
	cmd.Dir = directory
	return cmd, nil
}

func resolveProjectDirectory(relative string) (string, error)

{
	projectRoot, err := filepath.Abs(".")
	if err != nil {
		return "", err
	}
	resolvedRoot, err := filepath.EvalSymlinks(projectRoot)
	if err != nil {
		return "", err
	}
	resolvedDirectory, err := filepath.EvalSymlinks(filepath.Join(resolvedRoot, filepath.Clean(relative)))
	if err != nil {
		return "", err
	}
	info, err := os.Stat(resolvedDirectory)
	if err != nil {
		return "", err
	}
	if !info.IsDir() {
		return "", fmt.Errorf("%q is not a directory", relative)
	}
	pathWithinRoot, err := filepath.Rel(resolvedRoot, resolvedDirectory)
	if err != nil || pathWithinRoot == ".." || strings.HasPrefix(pathWithinRoot, ".."+string(filepath.Separator)) {
		return "", fmt.Errorf("%q resolves outside the project", relative)
	}
	return resolvedDirectory, nil
}

func TestValidatePackagePattern(t *testing.T)

{
	for _, pattern := range []string{".", "./...", "./pkg/...", "./foo-bar", "example.com/team/module/pkg"} {
		if err := validatePackagePattern(pattern); err != nil {
			t.Errorf("expected %q to be valid: %v", pattern, err)
		}
	}
	for _, pattern := range []string{"", "-exec=sh", "../...", "/tmp/pkg", "./pkg name", "./pkg=./other", "./pkg/.../nested"} {
		if err := validatePackagePattern(pattern); err == nil {
			t.Errorf("expected %q to be rejected", pattern)
		}
	}
}

func TestConfiguredPackagesDefaultsToCurrentPackage(t *testing.T)

{
	for _, packages := range [][]string{nil, {}} {
		configured := configuredPackages(packages)
		if len(configured) != 1 || configured[0] != "." {
			t.Fatalf("configured packages %v, want current package", configured)
		}
	}

	configured := configuredPackages([]string{"./..."})
	if len(configured) != 1 || configured[0] != "./..." {
		t.Fatalf("configured packages %v, want recursive project pattern", configured)
	}
}

func TestPackageTestCommand(t *testing.T)

{
	root := t.TempDir()
	packageDirectory := filepath.Join(root, "pkg")
	if err := os.Mkdir(packageDirectory, 0o750); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(root, "go.mod"), []byte("module example.com/team/module\n\ngo 1.25\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	oldWorkingDirectory, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Chdir(root); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() {
		if err := os.Chdir(oldWorkingDirectory); err != nil {
			t.Errorf("restore working directory: %v", err)
		}
	})

	cmd, err := packageTestCommand("./pkg/...")
	if err != nil {
		t.Fatalf("create package test command: %v", err)
	}
	if cmd.Path == "" || len(cmd.Args) != 3 || cmd.Args[1] != "test" || cmd.Args[2] != "./..." {
		t.Fatalf("unexpected command: path=%q args=%v", cmd.Path, cmd.Args)
	}
	resolvedPackageDirectory, err := filepath.EvalSymlinks(packageDirectory)
	if err != nil {
		t.Fatal(err)
	}
	if cmd.Dir != resolvedPackageDirectory {
		t.Fatalf("command directory %q, want %q", cmd.Dir, resolvedPackageDirectory)
	}

	moduleCommand, err := packageTestCommand("example.com/team/module/pkg")
	if err != nil {
		t.Fatalf("create module package test command: %v", err)
	}
	if moduleCommand.Dir != resolvedPackageDirectory || moduleCommand.Args[2] != "." {
		t.Fatalf("unexpected module command: dir=%q args=%v", moduleCommand.Dir, moduleCommand.Args)
	}
	if _, err := packageTestCommand("example.com/other/module/pkg"); err == nil {
		t.Fatal("expected external module package to be rejected")
	}

	outside := t.TempDir()
	if err := os.Symlink(outside, filepath.Join(root, "outside")); err != nil {
		t.Fatal(err)
	}
	if _, err := packageTestCommand("./outside"); err == nil {
		t.Fatal("expected symlink escape to be rejected")
	}
}