295 lines
9.1 KiB
Go
295 lines
9.1 KiB
Go
package main
|
|
|
|
import (
|
|
"archive/zip"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestParseRSILatestElectronBuilder(t *testing.T) {
|
|
y := `version: 2.15.0
|
|
files:
|
|
- url: RSI Launcher-Setup-2.15.0.exe
|
|
sha512: nested-sha
|
|
size: 123
|
|
path: RSI Launcher-Setup-2.15.0.exe
|
|
sha512: top-sha
|
|
releaseDate: '2026-07-27T18:00:00.000Z'
|
|
`
|
|
file, sha, err := parseRSILatestYML([]byte(y))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if file != "RSI Launcher-Setup-2.15.0.exe" || sha != "top-sha" {
|
|
t.Fatalf("unexpected: file=%q sha=%q", file, sha)
|
|
}
|
|
}
|
|
|
|
func TestParseRSILatestNestedOnly(t *testing.T) {
|
|
y := `version: 2.15.0
|
|
files:
|
|
- url: "RSI Launcher-Setup-2.15.0.exe"
|
|
sha512: "nested-sha"
|
|
`
|
|
file, sha, err := parseRSILatestYML([]byte(y))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if file != "RSI Launcher-Setup-2.15.0.exe" || sha != "nested-sha" {
|
|
t.Fatalf("unexpected: file=%q sha=%q", file, sha)
|
|
}
|
|
}
|
|
|
|
func TestParseRSILatestVersionFallback(t *testing.T) {
|
|
file, _, err := parseRSILatestYML([]byte("version: 2.15.0\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if file != "RSI Launcher-Setup-2.15.0.exe" {
|
|
t.Fatalf("unexpected file %q", file)
|
|
}
|
|
}
|
|
|
|
func TestBasePrefixDoesNotUseFragilePowerShellMSI(t *testing.T) {
|
|
for _, v := range basePrefixWinetricksVerbs {
|
|
if strings.EqualFold(v, "powershell") {
|
|
t.Fatalf("PowerShell must be managed by the verified portable compatibility layer, not Winetricks/MSI")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWineRegistryKeyUsesSingleSeparators(t *testing.T) {
|
|
if strings.Contains(wineFileAssociationsKey, `\\`) {
|
|
t.Fatalf("registry key contains doubled separators: %q", wineFileAssociationsKey)
|
|
}
|
|
if wineFileAssociationsKey != `HKEY_CURRENT_USER\Software\Wine\FileOpenAssociations` {
|
|
t.Fatalf("unexpected registry key: %q", wineFileAssociationsKey)
|
|
}
|
|
}
|
|
|
|
func TestPowerShellStateRequiresFilesAndMarker(t *testing.T) {
|
|
a := testApp(t)
|
|
prefix := filepath.Join(a.home, "Games", "star-citizen")
|
|
core, profile, wrapper64, wrapper32 := a.powerShellPaths(prefix)
|
|
for _, p := range []string{core, profile, wrapper64, wrapper32} {
|
|
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(p, make([]byte, 2048), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if got := a.powerShellState(prefix); got != "repair" {
|
|
t.Fatalf("without verification marker got %q", got)
|
|
}
|
|
if err := a.writePowerShellMarker(prefix, powerShellCoreVersion+"+wrapper-"+powerShellWrapperVersion); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := a.powerShellState(prefix); got != "ready" {
|
|
t.Fatalf("managed compatibility layer got %q", got)
|
|
}
|
|
if err := os.Remove(wrapper64); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := a.powerShellState(prefix); got != "repair" {
|
|
t.Fatalf("missing wrapper got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestPowerShellPinnedArtifactsUseSHA256(t *testing.T) {
|
|
for name, sha := range map[string]string{
|
|
"PowerShell Core": powerShellCoreSHA256,
|
|
"PowerShell wrapper": powerShellWrapperSHA256,
|
|
} {
|
|
if len(sha) != 64 {
|
|
t.Fatalf("%s SHA-256 length=%d", name, len(sha))
|
|
}
|
|
for _, c := range sha {
|
|
if !strings.ContainsRune("0123456789abcdefABCDEF", c) {
|
|
t.Fatalf("%s contains non-hex SHA-256 %q", name, sha)
|
|
}
|
|
}
|
|
}
|
|
if !strings.Contains(powerShellCoreURL, powerShellCoreVersion) || !strings.Contains(powerShellWrapperURL, powerShellWrapperVersion) {
|
|
t.Fatal("pinned PowerShell URLs do not match pinned versions")
|
|
}
|
|
if powerShellCoreSHA256 != "cd62ad6d8174cc6fb85b335a0058444bc934fe27c39fa97fe342134286d28af9" {
|
|
t.Fatal("PowerShell Core checksum drifted from upstream v7.4.19 release")
|
|
}
|
|
if powerShellWrapperSHA256 != "08f866265e0395f4bc5ddb18f3dff345771d039a62911e506c62084fd2533ec3" {
|
|
t.Fatal("PowerShell wrapper checksum drifted from upstream v3.0.5 release")
|
|
}
|
|
}
|
|
|
|
func TestExtractZipSafeRejectsTraversalAndSymlink(t *testing.T) {
|
|
makeZip := func(name string, mode os.FileMode) string {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "test.zip")
|
|
f, err := os.Create(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
zw := zip.NewWriter(f)
|
|
h := &zip.FileHeader{Name: name, Method: zip.Store}
|
|
h.SetMode(mode)
|
|
w, err := zw.CreateHeader(h)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _ = w.Write([]byte("payload"))
|
|
if err := zw.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
}
|
|
if err := extractZipSafe(makeZip("../escape", 0o644), t.TempDir()); err == nil {
|
|
t.Fatal("ZIP traversal was accepted")
|
|
}
|
|
if err := extractZipSafe(makeZip("link", os.ModeSymlink|0o777), t.TempDir()); err == nil {
|
|
t.Fatal("ZIP symlink was accepted")
|
|
}
|
|
}
|
|
|
|
func TestFormatCommandFailureHandlesMissingExpectedOutput(t *testing.T) {
|
|
if got := formatCommandFailure(nil, nil); got == "" {
|
|
t.Fatal("nil error and empty output should still yield a diagnostic")
|
|
}
|
|
if got := formatCommandFailure(nil, []byte("unexpected output")); got != "unexpected output" {
|
|
t.Fatalf("unexpected diagnostic %q", got)
|
|
}
|
|
}
|
|
|
|
func TestRequiredReleaseDigestFailsClosed(t *testing.T) {
|
|
p := filepath.Join(t.TempDir(), "asset")
|
|
if err := os.WriteFile(p, []byte("abc"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := requireReleaseDigest(p, ""); err == nil {
|
|
t.Fatal("missing digest was accepted")
|
|
}
|
|
if err := requireReleaseDigest(p, "md5:deadbeef"); err == nil {
|
|
t.Fatal("non-SHA256 digest was accepted")
|
|
}
|
|
if err := requireReleaseDigest(p, "sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); err != nil {
|
|
t.Fatalf("known SHA-256 rejected: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVulkanHardwareSelectionIgnoresLLVMPipeWhenRealGPUExists(t *testing.T) {
|
|
summary := `Devices:
|
|
========
|
|
GPU0:
|
|
apiVersion = 1.4.305
|
|
deviceType = PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
|
|
deviceName = AMD Radeon Graphics (RADV PHOENIX2)
|
|
GPU1:
|
|
apiVersion = 1.4.305
|
|
deviceType = PHYSICAL_DEVICE_TYPE_CPU
|
|
deviceName = llvmpipe (LLVM 19.1.7, 256 bits)
|
|
`
|
|
dev, ok := selectVulkanHardwareDevice(summary)
|
|
if !ok {
|
|
t.Fatal("real Vulkan GPU was rejected because a software ICD was also present")
|
|
}
|
|
if dev.Name != "AMD Radeon Graphics (RADV PHOENIX2)" {
|
|
t.Fatalf("selected GPU=%q", dev.Name)
|
|
}
|
|
if dev.APIMajor != 1 || dev.APIMinor != 4 {
|
|
t.Fatalf("selected Vulkan version=%d.%d", dev.APIMajor, dev.APIMinor)
|
|
}
|
|
}
|
|
|
|
func TestVulkanHardwareSelectionRejectsSoftwareOnly(t *testing.T) {
|
|
summary := `Devices:
|
|
========
|
|
GPU0:
|
|
apiVersion = 1.4.305
|
|
deviceType = PHYSICAL_DEVICE_TYPE_CPU
|
|
deviceName = llvmpipe (LLVM 19.1.7, 256 bits)
|
|
`
|
|
if dev, ok := selectVulkanHardwareDevice(summary); ok {
|
|
t.Fatalf("software-only Vulkan device accepted: %#v", dev)
|
|
}
|
|
}
|
|
|
|
func TestPowerShellProbeAcceptsSuccessfulWrapperWithoutStdout(t *testing.T) {
|
|
a := testApp(t)
|
|
prefix := filepath.Join(a.home, "Games", "star-citizen")
|
|
gc := GameConfig{Prefix: prefix}
|
|
core, _, wrapper64, _ := a.powerShellPaths(prefix)
|
|
for _, p := range []string{core, wrapper64} {
|
|
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(p, make([]byte, 2048), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
runner := filepath.Join(a.vendorDir, "wine", "fixture")
|
|
bin := filepath.Join(runner, "bin")
|
|
if err := os.MkdirAll(bin, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// The fixture intentionally emits no stdout: this reproduces the real Wine
|
|
// behavior from the 1.0.0 support bundle.
|
|
for _, name := range []string{"wine", "wineserver"} {
|
|
p := filepath.Join(bin, name)
|
|
if err := os.WriteFile(p, []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(a.vendorDir, "wine"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(runner, filepath.Join(a.vendorDir, "wine", "current")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := a.probePowerShell(gc, os.Environ()); err != nil {
|
|
t.Fatalf("successful wrapper without stdout was rejected: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGameStatusStillReportsInstalledComponentsWhenHealthIsBlocked(t *testing.T) {
|
|
a := testApp(t)
|
|
prefix := filepath.Join(a.home, "Games", "star citizen") // intentionally invalid path: forces blocked health
|
|
gc := GameConfig{
|
|
Prefix: prefix,
|
|
LauncherEXE: filepath.Join(prefix, "drive_c", "Program Files", "Roberts Space Industries", "RSI Launcher", "RSI Launcher.exe"),
|
|
GameDir: filepath.Join(prefix, "drive_c", "Program Files", "Roberts Space Industries", "StarCitizen"),
|
|
}
|
|
for _, p := range []string{
|
|
filepath.Join(prefix, "drive_c"),
|
|
filepath.Dir(gc.LauncherEXE),
|
|
filepath.Join(gc.GameDir, "LIVE", "Bin64"),
|
|
} {
|
|
if err := os.MkdirAll(p, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
for _, p := range []string{
|
|
filepath.Join(prefix, "system.reg"),
|
|
filepath.Join(prefix, "user.reg"),
|
|
gc.LauncherEXE,
|
|
filepath.Join(gc.GameDir, "LIVE", "Bin64", "StarCitizen.exe"),
|
|
} {
|
|
if err := os.WriteFile(p, []byte("fixture"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := a.saveGameConfig(gc); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st := a.gameStatus()
|
|
if st.Health != "hardware-blocked" {
|
|
t.Fatalf("health=%q want hardware-blocked", st.Health)
|
|
}
|
|
if st.PrefixState != "ready" || st.LauncherState != "ready" || st.GameState != "ready" {
|
|
t.Fatalf("blocked health hid real component state: prefix=%s launcher=%s game=%s", st.PrefixState, st.LauncherState, st.GameState)
|
|
}
|
|
}
|