391 lines
19 KiB
Go
391 lines
19 KiB
Go
package bootstrap
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func init() {
|
|
chocoCommand = "choco"
|
|
}
|
|
|
|
func TestChocoInstallArgsUseExactNonInteractiveFlags(t *testing.T) {
|
|
pkg := Package{Name: "Git", ChocoID: "git"}
|
|
want := []string{"install", "git", "-y", "--no-progress"}
|
|
if got := ChocoInstallArgs(pkg); !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("args = %#v, want %#v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPreparePackageForInstallWritesVisualStudioConfigAndOverride(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "Visual Studio Community 2026",
|
|
ChocoID: "visualstudio2022community",
|
|
InstallerArgs: "--passive --config {config}",
|
|
ChocoConfigAsset: "assets/visual-studio-community.vsconfig",
|
|
}
|
|
prepared, err := PreparePackageForInstall(pkg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(prepared.InstallerArgs, "{config}") {
|
|
t.Fatalf("override still has placeholder: %q", prepared.InstallerArgs)
|
|
}
|
|
args := ChocoInstallArgs(prepared)
|
|
joined := strings.Join(args, " ")
|
|
if !strings.Contains(joined, "--install-arguments") || !strings.Contains(joined, "visual-studio-community.vsconfig") {
|
|
t.Fatalf("choco args missing VS config override: %#v", args)
|
|
}
|
|
}
|
|
|
|
func TestPreparePackageForInstallHandlesNoAssetAndMissingAsset(t *testing.T) {
|
|
pkg := Package{Name: "Git", ChocoID: "git"}
|
|
prepared, err := PreparePackageForInstall(pkg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(prepared, pkg) {
|
|
t.Fatalf("prepared = %#v, want unchanged package", prepared)
|
|
}
|
|
|
|
_, err = PreparePackageForInstall(Package{Name: "broken", ChocoConfigAsset: "assets/missing.vsconfig"})
|
|
if err == nil {
|
|
t.Fatal("expected missing asset error")
|
|
}
|
|
}
|
|
|
|
func TestChocoInstalledStateParsing(t *testing.T) {
|
|
pkg := Package{ChocoID: "git"}
|
|
if !ChocoOutputShowsInstalled(pkg, "Chocolatey v1.2.1\ngit 2.40.1\n1 packages installed.") {
|
|
t.Fatal("expected installed output to be detected")
|
|
}
|
|
if ChocoOutputShowsInstalled(pkg, "Chocolatey v1.2.1\n0 packages installed.") {
|
|
t.Fatal("expected missing package output to be false")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesKeepsStableOrderAndAggregatesErrors(t *testing.T) {
|
|
a := Package{Name: "A", ChocoID: "a"}
|
|
b := Package{Name: "B", ChocoID: "b"}
|
|
runner := &fakeRunner{responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "Test-Path C:\\ProgramData\\chocolatey\\lib\\a"): {Stdout: "True\n"},
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "Test-Path C:\\ProgramData\\chocolatey\\lib\\b"): {Err: errors.New("boom"), Stderr: "source unavailable"},
|
|
}}
|
|
states := CheckPackages(context.Background(), runner, []Package{a, b}, 2)
|
|
if len(states) != 2 || states[0].Package.Name != "A" || states[1].Package.Name != "B" {
|
|
t.Fatalf("states not in input order: %#v", states)
|
|
}
|
|
if !states[0].Installed {
|
|
t.Fatal("first package should be installed")
|
|
}
|
|
if states[1].CheckErr == nil {
|
|
t.Fatal("second package should keep check error")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesUsesSingleWorkerMinimumAndMissingPackageIsPending(t *testing.T) {
|
|
pkg := Package{Name: "Git", ChocoID: "git"}
|
|
runner := &fakeRunner{responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "Test-Path C:\\ProgramData\\chocolatey\\lib\\git"): {Stdout: "False\n"},
|
|
}}
|
|
states := CheckPackages(context.Background(), runner, []Package{pkg}, 0)
|
|
if len(states) != 1 {
|
|
t.Fatalf("states = %d, want 1", len(states))
|
|
}
|
|
if states[0].Installed || states[0].CheckErr != nil {
|
|
t.Fatalf("state = %#v, want pending without check error", states[0])
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesContinuesAfterFailure(t *testing.T) {
|
|
a := Package{Name: "A", ChocoID: "a"}
|
|
b := Package{Name: "B", ChocoID: "b"}
|
|
runner := &fakeRunner{responses: map[string]CommandResult{
|
|
commandKey("choco", ChocoInstallArgs(a)...): {Err: errors.New("boom"), Stderr: "failed"},
|
|
commandKey("choco", ChocoInstallArgs(b)...): {},
|
|
}, defaultErr: true}
|
|
issues := InstallPackages(context.Background(), runner, []Package{a, b})
|
|
if len(issues) != 1 {
|
|
t.Fatalf("issues = %d, want 1", len(issues))
|
|
}
|
|
if !runner.called("choco", ChocoInstallArgs(b)...) {
|
|
t.Fatal("second package should still be attempted after first failure")
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesReportsPrepareFailure(t *testing.T) {
|
|
issues := InstallPackages(context.Background(), &fakeRunner{defaultErr: true}, []Package{{
|
|
Name: "broken",
|
|
ChocoConfigAsset: "assets/missing.vsconfig",
|
|
}})
|
|
if len(issues) != 1 || !strings.Contains(issues[0].Step, "prepare broken") {
|
|
t.Fatalf("issues = %#v, want prepare failure", issues)
|
|
}
|
|
}
|
|
|
|
func TestWriteInstallAssetReportsCacheDirectoryError(t *testing.T) {
|
|
temp := t.TempDir()
|
|
cacheFile := filepath.Join(temp, "cache-file")
|
|
if err := os.WriteFile(cacheFile, []byte("not a directory"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("LOCALAPPDATA", cacheFile)
|
|
t.Setenv("LocalAppData", cacheFile)
|
|
if _, err := writeInstallAsset("assets/visual-studio-community.vsconfig"); err == nil {
|
|
t.Fatal("expected cache directory error")
|
|
}
|
|
}
|
|
|
|
func TestWriteInstallAssetFallsBackToTempDirWhenUserCacheIsUnavailable(t *testing.T) {
|
|
t.Setenv("LOCALAPPDATA", "")
|
|
t.Setenv("LocalAppData", "")
|
|
path, err := writeInstallAsset("assets/visual-studio-community.vsconfig")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if filepath.Base(path) != "visual-studio-community.vsconfig" {
|
|
t.Fatalf("path = %q", path)
|
|
}
|
|
}
|
|
|
|
func TestWriteInstallAssetReportsWriteError(t *testing.T) {
|
|
cache := t.TempDir()
|
|
targetDir := filepath.Join(cache, "bootstrap_windows_env", "visual-studio-community.vsconfig")
|
|
if err := os.MkdirAll(targetDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("LOCALAPPDATA", cache)
|
|
t.Setenv("LocalAppData", cache)
|
|
if _, err := writeInstallAsset("assets/visual-studio-community.vsconfig"); err == nil {
|
|
t.Fatal("expected write error when target path is a directory")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesNvidiaDriver(t *testing.T) {
|
|
// Backup original functions and defer restore
|
|
oldFetch := fetchNvidiaDriverURLFn
|
|
oldGetInstalled := getInstalledNvidiaVersionFn
|
|
defer func() {
|
|
fetchNvidiaDriverURLFn = oldFetch
|
|
getInstalledNvidiaVersionFn = oldGetInstalled
|
|
}()
|
|
|
|
// Mock fetchNvidiaDriverURLFn to return a version
|
|
fetchNvidiaDriverURLFn = func(pfid string, driverType string) (string, string, error) {
|
|
if pfid != "995" {
|
|
t.Errorf("expected pfid 995, got %s", pfid)
|
|
}
|
|
if driverType != "Studio" {
|
|
t.Errorf("expected driverType Studio, got %s", driverType)
|
|
}
|
|
return "https://uk.download.nvidia.com/Windows/610.47/610.47-desktop-win10-win11-64bit-international-nsd-dch-whql.exe", "610.47", nil
|
|
}
|
|
|
|
// 1. Test case: Installed version matches API version -> should report installed = true
|
|
getInstalledNvidiaVersionFn = func(ctx context.Context, runner Runner) (string, error) {
|
|
return "610.47", nil
|
|
}
|
|
|
|
pkg := Package{
|
|
Name: "Nvidia Driver",
|
|
ChocoParams: "RTX 4090",
|
|
InstallerArgs: "Studio",
|
|
}
|
|
|
|
runner := &fakeRunner{}
|
|
states := CheckPackages(context.Background(), runner, []Package{pkg}, 1)
|
|
if len(states) != 1 {
|
|
t.Fatalf("expected 1 state, got %d", len(states))
|
|
}
|
|
if !states[0].Installed {
|
|
t.Error("expected Nvidia Driver to be reported as installed")
|
|
}
|
|
if states[0].CheckErr != nil {
|
|
t.Errorf("expected no check error, got %v", states[0].CheckErr)
|
|
}
|
|
|
|
// 2. Test case: Installed version does not match API version -> should report installed = false
|
|
getInstalledNvidiaVersionFn = func(ctx context.Context, runner Runner) (string, error) {
|
|
return "596.36", nil
|
|
}
|
|
|
|
states = CheckPackages(context.Background(), runner, []Package{pkg}, 1)
|
|
if len(states) != 1 {
|
|
t.Fatalf("expected 1 state, got %d", len(states))
|
|
}
|
|
if states[0].Installed {
|
|
t.Error("expected Nvidia Driver to be reported as not installed (pending)")
|
|
}
|
|
if states[0].CheckErr != nil {
|
|
t.Errorf("expected no check error, got %v", states[0].CheckErr)
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesNvidiaDriver(t *testing.T) {
|
|
// Backup original functions and defer restore
|
|
oldFetch := fetchNvidiaDriverURLFn
|
|
defer func() {
|
|
fetchNvidiaDriverURLFn = oldFetch
|
|
}()
|
|
|
|
fetchNvidiaDriverURLFn = func(pfid string, driverType string) (string, string, error) {
|
|
return "https://mock.nvidia.download/driver.exe", "610.47", nil
|
|
}
|
|
|
|
pkg := Package{
|
|
Name: "Nvidia Driver",
|
|
ChocoParams: "RTX 4090",
|
|
InstallerArgs: "Studio",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'NvidiaDriver.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Nvidia driver...\"\nInvoke-WebRequest -Uri 'https://mock.nvidia.download/driver.exe' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Nvidia driver silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '-s' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1) {\n throw \"Nvidia driver installation failed with exit code \" + $p.ExitCode\n}\n"): {},
|
|
},
|
|
}
|
|
|
|
issues := InstallPackages(context.Background(), runner, []Package{pkg})
|
|
if len(issues) != 0 {
|
|
t.Fatalf("expected no issues, got: %v", issues)
|
|
}
|
|
|
|
if !runner.called("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'NvidiaDriver.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Nvidia driver...\"\nInvoke-WebRequest -Uri 'https://mock.nvidia.download/driver.exe' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Nvidia driver silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '-s' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1) {\n throw \"Nvidia driver installation failed with exit code \" + $p.ExitCode\n}\n") {
|
|
t.Error("expected Nvidia installer script to be executed")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesNvidiaBroadcast(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "Nvidia Broadcast",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", `if (Test-Path "${env:ProgramFiles}\NVIDIA Corporation\NVIDIA Broadcast\NVIDIA Broadcast.exe") { 'yes' } else { 'no' }`): {
|
|
Stdout: "yes\n",
|
|
},
|
|
},
|
|
}
|
|
|
|
states := CheckPackages(context.Background(), runner, []Package{pkg}, 1)
|
|
if len(states) != 1 {
|
|
t.Fatalf("expected 1 state, got %d", len(states))
|
|
}
|
|
if !states[0].Installed {
|
|
t.Error("expected Nvidia Broadcast to be reported as installed")
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesNvidiaBroadcast(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "Nvidia Broadcast",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'NvidiaBroadcast.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Nvidia Broadcast...\"\nInvoke-WebRequest -Uri 'https://international.download.nvidia.com/Windows/broadcast/2.2.0/NVIDIA_Broadcast_v2.2.0.52896077.exe' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Nvidia Broadcast silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '/s' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"Nvidia Broadcast installation failed with exit code \" + $p.ExitCode\n}\n"): {},
|
|
},
|
|
}
|
|
|
|
issues := InstallPackages(context.Background(), runner, []Package{pkg})
|
|
if len(issues) != 0 {
|
|
t.Fatalf("expected no issues, got: %v", issues)
|
|
}
|
|
|
|
if !runner.called("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'NvidiaBroadcast.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Nvidia Broadcast...\"\nInvoke-WebRequest -Uri 'https://international.download.nvidia.com/Windows/broadcast/2.2.0/NVIDIA_Broadcast_v2.2.0.52896077.exe' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Nvidia Broadcast silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '/s' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"Nvidia Broadcast installation failed with exit code \" + $p.ExitCode\n}\n") {
|
|
t.Error("expected Nvidia Broadcast installer script to be executed")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesAmdAutoDetect(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "AMD Auto-Detect",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", `if (Test-Path "${env:ProgramFiles}\AMD\CNext\CNext\RadeonSoftware.exe" -or Test-Path "${env:ProgramFiles}\AMD\CNext\CNext\AMDRSServ.exe") { 'yes' } else { 'no' }`): {
|
|
Stdout: "yes\n",
|
|
},
|
|
},
|
|
}
|
|
|
|
states := CheckPackages(context.Background(), runner, []Package{pkg}, 1)
|
|
if len(states) != 1 {
|
|
t.Fatalf("expected 1 state, got %d", len(states))
|
|
}
|
|
if !states[0].Installed {
|
|
t.Error("expected AMD Auto-Detect to be reported as installed")
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesAmdAutoDetect(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "AMD Auto-Detect",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'AMDMinimalSetup.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading AMD Auto-Detect tool...\"\nInvoke-WebRequest -Uri 'https://drivers.amd.com/drivers/installer/26.10/whql/amd-software-adrenalin-edition-26.6.1-minimalsetup-260601_web.exe' -OutFile $tempExe -UseBasicParsing -Headers @{\"Referer\" = \"https://www.amd.com/\"} -UserAgent \"Mozilla/5.0 (Windows NT 10.0; Win64; x64)\" -ErrorAction Stop\nWrite-Host \"Launching AMD Auto-Detect tool...\"\n$p = Start-Process -FilePath $tempExe -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"AMD Auto-Detect failed with exit code \" + $p.ExitCode\n}\n"): {},
|
|
},
|
|
}
|
|
|
|
issues := InstallPackages(context.Background(), runner, []Package{pkg})
|
|
if len(issues) != 0 {
|
|
t.Fatalf("expected no issues, got: %v", issues)
|
|
}
|
|
|
|
if !runner.called("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'AMDMinimalSetup.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading AMD Auto-Detect tool...\"\nInvoke-WebRequest -Uri 'https://drivers.amd.com/drivers/installer/26.10/whql/amd-software-adrenalin-edition-26.6.1-minimalsetup-260601_web.exe' -OutFile $tempExe -UseBasicParsing -Headers @{\"Referer\" = \"https://www.amd.com/\"} -UserAgent \"Mozilla/5.0 (Windows NT 10.0; Win64; x64)\" -ErrorAction Stop\nWrite-Host \"Launching AMD Auto-Detect tool...\"\n$p = Start-Process -FilePath $tempExe -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"AMD Auto-Detect failed with exit code \" + $p.ExitCode\n}\n") {
|
|
t.Error("expected AMD Auto-Detect installer script to be executed")
|
|
}
|
|
}
|
|
|
|
func TestCheckPackagesIntelDSA(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "Intel DSA",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", `if (Test-Path "${env:ProgramFiles(x86)}\Intel\Driver and Support Assistant\DSAService.exe") { 'yes' } else { 'no' }`): {
|
|
Stdout: "yes\n",
|
|
},
|
|
},
|
|
}
|
|
|
|
states := CheckPackages(context.Background(), runner, []Package{pkg}, 1)
|
|
if len(states) != 1 {
|
|
t.Fatalf("expected 1 state, got %d", len(states))
|
|
}
|
|
if !states[0].Installed {
|
|
t.Error("expected Intel DSA to be reported as installed")
|
|
}
|
|
}
|
|
|
|
func TestInstallPackagesIntelDSA(t *testing.T) {
|
|
pkg := Package{
|
|
Name: "Intel DSA",
|
|
}
|
|
|
|
runner := &fakeRunner{
|
|
responses: map[string]CommandResult{
|
|
commandKey("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'IntelDSAInstaller.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Intel Driver & Support Assistant...\"\nInvoke-WebRequest -Uri 'https://dsadata.intel.com/installer' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Intel Driver & Support Assistant silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '-s', '-norestart' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"Intel DSA installation failed with exit code \" + $p.ExitCode\n}\n"): {},
|
|
},
|
|
}
|
|
|
|
issues := InstallPackages(context.Background(), runner, []Package{pkg})
|
|
if len(issues) != 0 {
|
|
t.Fatalf("expected no issues, got: %v", issues)
|
|
}
|
|
|
|
if !runner.called("powershell.exe", "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "\n$tempExe = Join-Path $env:TEMP 'IntelDSAInstaller.exe'\nif (Test-Path $tempExe) { Remove-Item -Force $tempExe }\n[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072\nWrite-Host \"Downloading Intel Driver & Support Assistant...\"\nInvoke-WebRequest -Uri 'https://dsadata.intel.com/installer' -OutFile $tempExe -UseBasicParsing -ErrorAction Stop\nWrite-Host \"Installing Intel Driver & Support Assistant silently...\"\n$p = Start-Process -FilePath $tempExe -ArgumentList '-s', '-norestart' -Wait -PassThru\nRemove-Item -Force $tempExe\nif ($p.ExitCode -ne 0 -and $p.ExitCode -ne 1 -and $p.ExitCode -ne 3010) {\n throw \"Intel DSA installation failed with exit code \" + $p.ExitCode\n}\n") {
|
|
t.Error("expected Intel DSA installer script to be executed")
|
|
}
|
|
}
|
|
|