mirror of
https://github.com/Jguer/yay.git
synced 2024-11-06 09:07:21 +01:00
04c76a404e
* feat(install): add --nocleanbuild to keep pkg/ and src/ directories for AUR packages Providing this flag during installation of AUR packages allows for keeping the src/ and pkg/ directories produced my makepkg. If the user wants to delete the directories, they can either select to cleanBuild in the cleanmenu or run the installation without the --nocleanbuild flag (yay will only remove the directories if the package is rebuilt) * fix(completion): simplify description for --nocleanbuild in fish This makes the description consistent with the descriptions in the man page, --help, and zsh completion. * refactor(install): Rename --nocleanbuild to --keepsrc This naming scheme is more familiar to users since it is the name of the flag in Paru. --------- Co-authored-by: jguer <me@jguer.space>
1029 lines
31 KiB
Go
1029 lines
31 KiB
Go
//go:build !integration
|
|
// +build !integration
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
aur "github.com/Jguer/aur"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/Jguer/yay/v12/pkg/db/mock"
|
|
mockaur "github.com/Jguer/yay/v12/pkg/dep/mock"
|
|
"github.com/Jguer/yay/v12/pkg/runtime"
|
|
"github.com/Jguer/yay/v12/pkg/settings"
|
|
"github.com/Jguer/yay/v12/pkg/settings/exe"
|
|
"github.com/Jguer/yay/v12/pkg/settings/parser"
|
|
"github.com/Jguer/yay/v12/pkg/text"
|
|
"github.com/Jguer/yay/v12/pkg/vcs"
|
|
)
|
|
|
|
func newTestLogger() *text.Logger {
|
|
return text.NewLogger(io.Discard, io.Discard, strings.NewReader(""), true, "test")
|
|
}
|
|
|
|
func TestIntegrationLocalInstall(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
tars := []string{
|
|
tmpDir + "/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"pacman -S --config /etc/pacman.conf -- community/dotnet-sdk-6.0 community/dotnet-runtime-6.0",
|
|
"pacman -D -q --asdeps --config /etc/pacman.conf -- dotnet-runtime-6.0 dotnet-sdk-6.0",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst /testdir/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- jellyfin-server jellyfin-web",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- jellyfin",
|
|
}
|
|
|
|
wantCapture := []string{
|
|
"makepkg --packagelist",
|
|
"git -C testdata/jfin git reset --hard HEAD",
|
|
"git -C testdata/jfin git merge --no-edit --ff",
|
|
"makepkg --packagelist",
|
|
"makepkg --packagelist",
|
|
}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget("testdata/jfin")
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7", "dotnet-runtime>=6", "dotnet-runtime<7", "jellyfin-server=10.8.4", "jellyfin-web=10.8.4":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
switch s {
|
|
case "dotnet-runtime>=6", "dotnet-runtime<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-runtime-6.0",
|
|
PBase: "dotnet-runtime-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-sdk-6.0",
|
|
PBase: "dotnet-sdk-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
LocalPackageFn: func(s string) mock.IPackage { return nil },
|
|
InstalledRemotePackageNamesFn: func() []string { return []string{} },
|
|
}
|
|
|
|
run := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), run, cmdArgs, db)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallMissingDep(t *testing.T) {
|
|
wantErr := ErrPackagesNotFound
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
tars := []string{
|
|
tmpDir + "/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{}
|
|
wantCapture := []string{}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget("testdata/jfin")
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7", "dotnet-runtime>=6", "dotnet-runtime<7", "jellyfin-server=10.8.4", "jellyfin-web=10.8.4":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
switch s {
|
|
case "dotnet-runtime>=6", "dotnet-runtime<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-runtime-6.0",
|
|
PBase: "dotnet-runtime-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
LocalPackageFn: func(string) mock.IPackage { return nil },
|
|
}
|
|
|
|
run := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), run, cmdArgs, db)
|
|
require.ErrorContains(t, err, wantErr.Error())
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallNeeded(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
tars := []string{
|
|
tmpDir + "/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"pacman -S --config /etc/pacman.conf -- community/dotnet-sdk-6.0 community/dotnet-runtime-6.0",
|
|
"pacman -D -q --asdeps --config /etc/pacman.conf -- dotnet-runtime-6.0 dotnet-sdk-6.0",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
}
|
|
|
|
wantCapture := []string{
|
|
"makepkg --packagelist",
|
|
"git -C testdata/jfin git reset --hard HEAD",
|
|
"git -C testdata/jfin git merge --no-edit --ff",
|
|
"makepkg --packagelist",
|
|
"makepkg --packagelist",
|
|
}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddArg("needed")
|
|
cmdArgs.AddTarget("testdata/jfin")
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
IsCorrectVersionInstalledFn: func(s1, s2 string) bool {
|
|
return true
|
|
},
|
|
LocalPackageFn: func(s string) mock.IPackage {
|
|
if s == "jellyfin-server" {
|
|
return &mock.Package{
|
|
PName: "jellyfin-server",
|
|
PBase: "jellyfin-server",
|
|
PVersion: "10.8.4-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
return nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7", "dotnet-runtime>=6", "dotnet-runtime<7", "jellyfin-server=10.8.4", "jellyfin-web=10.8.4":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
switch s {
|
|
case "dotnet-runtime>=6", "dotnet-runtime<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-runtime-6.0",
|
|
PBase: "dotnet-runtime-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-sdk-6.0",
|
|
PBase: "dotnet-sdk-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
InstalledRemotePackageNamesFn: func() []string { return []string{} },
|
|
}
|
|
|
|
run := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), run, cmdArgs, db)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow), "show calls: %v", mockRunner.ShowCalls)
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallGenerateSRCINFO(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
srcinfo, err := os.ReadFile("testdata/jfin/.SRCINFO")
|
|
require.NoError(t, err)
|
|
assert.True(t, strings.HasPrefix(string(srcinfo), "pkgbase = jellyfin"), string(srcinfo))
|
|
|
|
targetDir := t.TempDir()
|
|
f, err = os.OpenFile(filepath.Join(targetDir, "PKGBUILD"), os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
tars := []string{
|
|
tmpDir + "/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"pacman -S --config /etc/pacman.conf -- community/dotnet-sdk-6.0 community/dotnet-runtime-6.0",
|
|
"pacman -D -q --asdeps --config /etc/pacman.conf -- dotnet-runtime-6.0 dotnet-sdk-6.0",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst /testdir/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- jellyfin-server jellyfin-web",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- jellyfin",
|
|
}
|
|
|
|
wantCapture := []string{
|
|
"makepkg --printsrcinfo",
|
|
"makepkg --packagelist",
|
|
"git -C testdata/jfin git reset --hard HEAD",
|
|
"git -C testdata/jfin git merge --no-edit --ff",
|
|
"makepkg --packagelist",
|
|
"makepkg --packagelist",
|
|
}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
for _, arg := range cmd.Args {
|
|
if arg == "--printsrcinfo" {
|
|
return string(srcinfo), "", nil
|
|
}
|
|
}
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget(targetDir)
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7", "dotnet-runtime>=6", "dotnet-runtime<7", "jellyfin-server=10.8.4", "jellyfin-web=10.8.4":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
LocalPackageFn: func(string) mock.IPackage { return nil },
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
switch s {
|
|
case "dotnet-runtime>=6", "dotnet-runtime<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-runtime-6.0",
|
|
PBase: "dotnet-runtime-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-sdk-6.0",
|
|
PBase: "dotnet-sdk-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
InstalledRemotePackageNamesFn: func() []string { return []string{} },
|
|
}
|
|
|
|
run := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
Debug: false,
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), run, cmdArgs, db)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallMissingFiles(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
srcinfo, err := os.ReadFile("testdata/jfin/.SRCINFO")
|
|
require.NoError(t, err)
|
|
|
|
targetDir := t.TempDir()
|
|
|
|
tars := []string{
|
|
tmpDir + "/jellyfin-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-web-10.8.4-1-x86_64.pkg.tar.zst",
|
|
tmpDir + "/jellyfin-server-10.8.4-1-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{}
|
|
|
|
wantCapture := []string{}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
if cmd.Args[1] == "--printsrcinfo" {
|
|
return string(srcinfo), "", nil
|
|
}
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget(targetDir)
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7", "dotnet-runtime>=6", "dotnet-runtime<7", "jellyfin-server=10.8.4", "jellyfin-web=10.8.4":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
switch s {
|
|
case "dotnet-runtime>=6", "dotnet-runtime<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-runtime-6.0",
|
|
PBase: "dotnet-runtime-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
case "dotnet-sdk>=6", "dotnet-sdk<7":
|
|
return &mock.Package{
|
|
PName: "dotnet-sdk-6.0",
|
|
PBase: "dotnet-sdk-6.0",
|
|
PVersion: "6.0.100-1",
|
|
PDB: mock.NewDB("community"),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
config := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
Debug: false,
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), config, cmdArgs, db)
|
|
require.ErrorIs(t, err, ErrNoBuildFiles)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallWithDepsProvides(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
tars := []string{
|
|
tmpDir + "/ceph-bin-17.2.6-2-x86_64.pkg.tar.zst",
|
|
tmpDir + "/ceph-libs-bin-17.2.6-2-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/ceph-libs-bin-17.2.6-2-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- ceph-libs-bin",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir/ceph-bin-17.2.6-2-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- ceph-bin",
|
|
}
|
|
|
|
wantCapture := []string{
|
|
"git -C testdata/cephbin git reset --hard HEAD",
|
|
"git -C testdata/cephbin git merge --no-edit --ff",
|
|
"makepkg --packagelist",
|
|
"makepkg --packagelist",
|
|
}
|
|
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
return strings.Join(tars, "\n"), "", nil
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range tars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget("testdata/cephbin")
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "ceph=17.2.6-2", "ceph-libs=17.2.6-2":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
return nil
|
|
},
|
|
LocalPackageFn: func(s string) mock.IPackage { return nil },
|
|
InstalledRemotePackageNamesFn: func() []string { return []string{} },
|
|
}
|
|
|
|
config := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), config, cmdArgs, db)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir, "/testdir") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|
|
|
|
func TestIntegrationLocalInstallTwoSrcInfosWithDeps(t *testing.T) {
|
|
makepkgBin := t.TempDir() + "/makepkg"
|
|
pacmanBin := t.TempDir() + "/pacman"
|
|
gitBin := t.TempDir() + "/git"
|
|
tmpDir1 := t.TempDir()
|
|
tmpDir2 := t.TempDir()
|
|
f, err := os.OpenFile(makepkgBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(pacmanBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
f, err = os.OpenFile(gitBin, os.O_RDONLY|os.O_CREATE, 0o755)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
|
|
pkgsTars := []string{
|
|
tmpDir1 + "/libzip-git-1.9.2.r166.gd2c47d0f-1-x86_64.pkg.tar.zst",
|
|
tmpDir2 + "/gourou-0.8.1-4-x86_64.pkg.tar.zst",
|
|
}
|
|
|
|
wantShow := []string{
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"makepkg --verifysource --skippgpcheck -f -Cc",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir1/libzip-git-1.9.2.r166.gd2c47d0f-1-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- libzip-git",
|
|
"makepkg --nobuild -f -C --ignorearch",
|
|
"makepkg -c --nobuild --noextract --ignorearch",
|
|
"pacman -U --config /etc/pacman.conf -- /testdir2/gourou-0.8.1-4-x86_64.pkg.tar.zst",
|
|
"pacman -D -q --asexplicit --config /etc/pacman.conf -- gourou",
|
|
}
|
|
|
|
wantCapture := []string{
|
|
"git -C testdata/gourou git reset --hard HEAD",
|
|
"git -C testdata/gourou git merge --no-edit --ff",
|
|
"git -C testdata/libzip-git git reset --hard HEAD",
|
|
"git -C testdata/libzip-git git merge --no-edit --ff",
|
|
"makepkg --packagelist",
|
|
"makepkg --packagelist",
|
|
}
|
|
|
|
captureCounter := 0
|
|
captureOverride := func(cmd *exec.Cmd) (stdout string, stderr string, err error) {
|
|
captureCounter++
|
|
switch captureCounter {
|
|
case 5:
|
|
return pkgsTars[0] + "\n", "", nil
|
|
case 6:
|
|
return pkgsTars[1] + "\n", "", nil
|
|
default:
|
|
return "", "", nil
|
|
}
|
|
}
|
|
|
|
once := sync.Once{}
|
|
|
|
showOverride := func(cmd *exec.Cmd) error {
|
|
once.Do(func() {
|
|
for _, tar := range pkgsTars {
|
|
f, err := os.OpenFile(tar, os.O_RDONLY|os.O_CREATE, 0o666)
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
}
|
|
})
|
|
return nil
|
|
}
|
|
|
|
mockRunner := &exe.MockRunner{CaptureFn: captureOverride, ShowFn: showOverride}
|
|
cmdBuilder := &exe.CmdBuilder{
|
|
MakepkgBin: makepkgBin,
|
|
SudoBin: "su",
|
|
PacmanBin: pacmanBin,
|
|
PacmanConfigPath: "/etc/pacman.conf",
|
|
GitBin: "git",
|
|
Runner: mockRunner,
|
|
SudoLoopEnabled: false,
|
|
}
|
|
|
|
cmdArgs := parser.MakeArguments()
|
|
cmdArgs.AddArg("B")
|
|
cmdArgs.AddArg("i")
|
|
cmdArgs.AddTarget("testdata/gourou")
|
|
cmdArgs.AddTarget("testdata/libzip-git")
|
|
settings.NoConfirm = true
|
|
defer func() { settings.NoConfirm = false }()
|
|
db := &mock.DBExecutor{
|
|
AlpmArchitecturesFn: func() ([]string, error) {
|
|
return []string{"x86_64"}, nil
|
|
},
|
|
LocalSatisfierExistsFn: func(s string) bool {
|
|
switch s {
|
|
case "gourou", "libzip", "libzip-git":
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
SyncSatisfierFn: func(s string) mock.IPackage {
|
|
return nil
|
|
},
|
|
LocalPackageFn: func(s string) mock.IPackage { return nil },
|
|
InstalledRemotePackageNamesFn: func() []string { return []string{} },
|
|
}
|
|
|
|
run := &runtime.Runtime{
|
|
Cfg: &settings.Configuration{
|
|
RemoveMake: "no",
|
|
},
|
|
Logger: newTestLogger(),
|
|
CmdBuilder: cmdBuilder,
|
|
VCSStore: &vcs.Mock{},
|
|
AURClient: &mockaur.MockAUR{
|
|
GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
|
|
return []aur.Pkg{}, nil
|
|
},
|
|
},
|
|
}
|
|
|
|
err = handleCmd(context.Background(), run, cmdArgs, db)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, mockRunner.ShowCalls, len(wantShow))
|
|
require.Len(t, mockRunner.CaptureCalls, len(wantCapture))
|
|
|
|
for i, call := range mockRunner.ShowCalls {
|
|
show := call.Args[0].(*exec.Cmd).String()
|
|
show = strings.ReplaceAll(show, tmpDir1, "/testdir1") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, tmpDir2, "/testdir2") // replace the temp dir with a static path
|
|
show = strings.ReplaceAll(show, makepkgBin, "makepkg")
|
|
show = strings.ReplaceAll(show, pacmanBin, "pacman")
|
|
show = strings.ReplaceAll(show, gitBin, "pacman")
|
|
|
|
// options are in a different order on different systems and on CI root user is used
|
|
assert.Subset(t, strings.Split(show, " "), strings.Split(wantShow[i], " "), fmt.Sprintf("%d - %s", i, show))
|
|
}
|
|
}
|