mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-11-21 04:46:29 +03:00
213 lines
6.6 KiB
Go
213 lines
6.6 KiB
Go
package updates
|
|
|
|
import (
|
|
"archive/tar"
|
|
"archive/zip"
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jesseduffield/lazygit/pkg/gui/types"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestAssetName(t *testing.T) {
|
|
// The assets of the v0.66.2 release
|
|
expectedNames := []string{
|
|
"lazygit_0.66.2_darwin_arm64.tar.gz",
|
|
"lazygit_0.66.2_darwin_x86_64.tar.gz",
|
|
"lazygit_0.66.2_freebsd_32-bit.tar.gz",
|
|
"lazygit_0.66.2_freebsd_arm64.tar.gz",
|
|
"lazygit_0.66.2_freebsd_armv6.tar.gz",
|
|
"lazygit_0.66.2_freebsd_x86_64.tar.gz",
|
|
"lazygit_0.66.2_linux_32-bit.tar.gz",
|
|
"lazygit_0.66.2_linux_arm64.tar.gz",
|
|
"lazygit_0.66.2_linux_armv6.tar.gz",
|
|
"lazygit_0.66.2_linux_x86_64.tar.gz",
|
|
"lazygit_0.66.2_windows_32-bit.zip",
|
|
"lazygit_0.66.2_windows_arm64.zip",
|
|
"lazygit_0.66.2_windows_x86_64.zip",
|
|
}
|
|
|
|
version := &types.VersionNumber{Major: 0, Minor: 66, Patch: 2}
|
|
names := []string{}
|
|
for _, goos := range []string{"darwin", "freebsd", "linux", "windows"} {
|
|
for _, goarch := range []string{"arm64", "amd64", "386", "arm"} {
|
|
// goreleaser doesn't build these
|
|
if (goos == "darwin" && (goarch == "386" || goarch == "arm")) || (goos == "windows" && goarch == "arm") {
|
|
continue
|
|
}
|
|
names = append(names, assetName(version, goos, goarch))
|
|
}
|
|
}
|
|
|
|
assert.ElementsMatch(t, expectedNames, names)
|
|
}
|
|
|
|
func TestAssetURL(t *testing.T) {
|
|
version := &types.VersionNumber{Major: 0, Minor: 67, Patch: 0}
|
|
assert.Equal(t,
|
|
"https://github.com/jesseduffield/lazygit/releases/download/v0.67.0/lazygit_0.67.0_linux_x86_64.tar.gz",
|
|
assetURL("https://github.com/jesseduffield/lazygit", version, "linux", "amd64"))
|
|
}
|
|
|
|
func TestExtractBinary(t *testing.T) {
|
|
files := map[string]string{
|
|
"LICENSE": "license",
|
|
"README.md": "readme",
|
|
"lazygit": "unix binary",
|
|
"lazygit.exe": "windows binary",
|
|
}
|
|
|
|
binary, err := extractBinary(makeTarGz(t, files), "lazygit_0.67.0_linux_x86_64.tar.gz", "lazygit")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "unix binary", string(binary))
|
|
|
|
binary, err = extractBinary(makeZip(t, files), "lazygit_0.67.0_windows_x86_64.zip", "lazygit.exe")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "windows binary", string(binary))
|
|
|
|
_, err = extractBinary(makeTarGz(t, map[string]string{"LICENSE": "license"}), "archive.tar.gz", "lazygit")
|
|
assert.EqualError(t, err, "archive.tar.gz doesn't contain lazygit")
|
|
|
|
_, err = extractBinary([]byte("not an archive"), "archive.tar.gz", "lazygit")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestReplaceExecutable(t *testing.T) {
|
|
for _, goos := range []string{"linux", "windows"} {
|
|
t.Run(goos, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
executablePath := filepath.Join(dir, "lazygit")
|
|
assert.NoError(t, os.WriteFile(executablePath, []byte("old"), 0o755))
|
|
|
|
assert.NoError(t, replaceExecutable(executablePath, []byte("new"), goos))
|
|
|
|
assertFileContent(t, executablePath, "new")
|
|
if runtime.GOOS != "windows" {
|
|
info, err := os.Stat(executablePath)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, os.FileMode(0o755), info.Mode().Perm())
|
|
}
|
|
assertDirContains(t, dir, "lazygit")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckCanReplaceExecutable(t *testing.T) {
|
|
dir := t.TempDir()
|
|
executablePath := filepath.Join(dir, "lazygit")
|
|
assert.NoError(t, os.WriteFile(executablePath, []byte("old"), 0o755))
|
|
|
|
assert.NoError(t, checkCanReplaceExecutable(executablePath))
|
|
assertDirContains(t, dir, "lazygit")
|
|
|
|
if runtime.GOOS == "windows" || os.Geteuid() == 0 {
|
|
// Windows ignores the permissions of folders, and root can write
|
|
// anywhere
|
|
return
|
|
}
|
|
|
|
assert.NoError(t, os.Chmod(dir, 0o555))
|
|
defer func() { _ = os.Chmod(dir, 0o755) }()
|
|
|
|
assert.ErrorIs(t, checkCanReplaceExecutable(executablePath), os.ErrPermission)
|
|
assert.ErrorIs(t, replaceExecutable(executablePath, []byte("new"), runtime.GOOS), os.ErrPermission)
|
|
assertFileContent(t, executablePath, "old")
|
|
}
|
|
|
|
func TestCleanUpAfterUpdate(t *testing.T) {
|
|
dir := t.TempDir()
|
|
executablePath := filepath.Join(dir, "lazygit")
|
|
for _, name := range []string{"lazygit", "lazygit.old", ".lazygit-old-123", ".lazygit-update-old", ".lazygit-update-new"} {
|
|
assert.NoError(t, os.WriteFile(filepath.Join(dir, name), []byte(name), 0o755))
|
|
}
|
|
twoHoursAgo := time.Now().Add(-2 * time.Hour)
|
|
assert.NoError(t, os.Chtimes(filepath.Join(dir, ".lazygit-update-old"), twoHoursAgo, twoHoursAgo))
|
|
|
|
cleanUpAfterUpdate(executablePath)
|
|
|
|
assertDirContains(t, dir, ".lazygit-update-new", "lazygit", "lazygit.old")
|
|
}
|
|
|
|
func TestDownloadBinary(t *testing.T) {
|
|
archive := makeTarGz(t, map[string]string{"LICENSE": "license", "lazygit": "new"})
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/releases/download/v0.67.0/lazygit_0.67.0_linux_x86_64.tar.gz" {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
_, _ = w.Write(archive)
|
|
}))
|
|
defer server.Close()
|
|
|
|
version := &types.VersionNumber{Major: 0, Minor: 67, Patch: 0}
|
|
url := assetURL(server.URL, version, "linux", "amd64")
|
|
binary, err := downloadBinary(context.Background(), server.Client(), url, "linux")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "new", string(binary))
|
|
|
|
url = assetURL(server.URL, version, "linux", "arm64")
|
|
_, err = downloadBinary(context.Background(), server.Client(), url, "linux")
|
|
assert.ErrorContains(t, err, "lazygit_0.67.0_linux_arm64.tar.gz returned 404 Not Found")
|
|
}
|
|
|
|
func makeTarGz(t *testing.T, files map[string]string) []byte {
|
|
t.Helper()
|
|
|
|
var buffer bytes.Buffer
|
|
gzipWriter := gzip.NewWriter(&buffer)
|
|
tarWriter := tar.NewWriter(gzipWriter)
|
|
for name, content := range files {
|
|
header := &tar.Header{Name: name, Mode: 0o755, Size: int64(len(content)), Typeflag: tar.TypeReg}
|
|
assert.NoError(t, tarWriter.WriteHeader(header))
|
|
_, err := tarWriter.Write([]byte(content))
|
|
assert.NoError(t, err)
|
|
}
|
|
assert.NoError(t, tarWriter.Close())
|
|
assert.NoError(t, gzipWriter.Close())
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
func makeZip(t *testing.T, files map[string]string) []byte {
|
|
t.Helper()
|
|
|
|
var buffer bytes.Buffer
|
|
zipWriter := zip.NewWriter(&buffer)
|
|
for name, content := range files {
|
|
writer, err := zipWriter.Create(name)
|
|
assert.NoError(t, err)
|
|
_, err = writer.Write([]byte(content))
|
|
assert.NoError(t, err)
|
|
}
|
|
assert.NoError(t, zipWriter.Close())
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
func assertFileContent(t *testing.T, path string, expected string) {
|
|
t.Helper()
|
|
|
|
content, err := os.ReadFile(path)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, expected, string(content))
|
|
}
|
|
|
|
func assertDirContains(t *testing.T, dir string, expected ...string) {
|
|
t.Helper()
|
|
|
|
entries, err := os.ReadDir(dir)
|
|
assert.NoError(t, err)
|
|
names := make([]string, 0, len(entries))
|
|
for _, entry := range entries {
|
|
names = append(names, entry.Name())
|
|
}
|
|
assert.ElementsMatch(t, expected, names)
|
|
}
|