1
0
mirror of https://github.com/jesseduffield/lazygit.git synced 2024-12-14 11:23:09 +02:00
lazygit/pkg/integration/integration.go

555 lines
14 KiB
Go
Raw Normal View History

2021-04-05 12:37:18 +02:00
package integration
import (
"encoding/json"
2022-01-26 07:46:54 +02:00
"errors"
2021-04-05 12:37:18 +02:00
"fmt"
"io/ioutil"
2022-01-09 05:09:15 +02:00
"log"
2021-04-05 12:37:18 +02:00
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"testing"
2021-04-05 12:37:18 +02:00
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
"github.com/jesseduffield/lazygit/pkg/secureexec"
)
type Test struct {
Name string `json:"name"`
Speed float64 `json:"speed"`
Description string `json:"description"`
ExtraCmdArgs string `json:"extraCmdArgs"`
Skip bool `json:"skip"`
2021-04-05 12:37:18 +02:00
}
type Mode int
const (
// default: for when we're just running a test and comparing to the snapshot
TEST = iota
// for when we want to record a test and set the snapshot based on the result
RECORD
// when we just want to use the setup of the test for our own sandboxing purposes.
// This does not record the session and does not create/update snapshots
SANDBOX
// running a test but updating the snapshot
UPDATE_SNAPSHOT
)
func GetModeFromEnv() Mode {
switch os.Getenv("MODE") {
case "record":
return RECORD
case "", "test":
return TEST
case "updateSnapshot":
return UPDATE_SNAPSHOT
case "sandbox":
return SANDBOX
default:
log.Fatalf("unknown test mode: %s, must be one of [test, record, update, sandbox]", os.Getenv("MODE"))
panic("unreachable")
}
}
2021-04-06 01:02:01 +02:00
// this function is used by both `go test` and from our lazyintegration gui, but
// errors need to be handled differently in each (for example go test is always
// working with *testing.T) so we pass in any differences as args here.
func RunTests(
logf func(format string, formatArgs ...interface{}),
runCmd func(cmd *exec.Cmd) error,
fnWrapper func(test *Test, f func(*testing.T) error),
mode Mode,
2021-04-06 01:02:01 +02:00
speedEnv string,
2021-10-22 11:18:40 +02:00
onFail func(t *testing.T, expected string, actual string, prefix string),
includeSkipped bool,
2021-04-06 01:02:01 +02:00
) error {
rootDir := GetRootDirectory()
err := os.Chdir(rootDir)
if err != nil {
return err
}
testDir := filepath.Join(rootDir, "test", "integration")
osCommand := oscommands.NewDummyOSCommand()
2021-12-29 05:33:38 +02:00
err = osCommand.Cmd.New("go build -o " + tempLazygitPath()).Run()
2021-04-06 01:02:01 +02:00
if err != nil {
return err
}
tests, err := LoadTests(testDir)
if err != nil {
return err
}
for _, test := range tests {
test := test
if test.Skip && !includeSkipped {
logf("skipping test: %s", test.Name)
continue
}
fnWrapper(test, func(t *testing.T) error {
speeds := getTestSpeeds(test.Speed, mode, speedEnv)
2021-04-06 01:02:01 +02:00
testPath := filepath.Join(testDir, test.Name)
2021-10-22 11:18:40 +02:00
actualRepoDir := filepath.Join(testPath, "actual")
expectedRepoDir := filepath.Join(testPath, "expected")
actualRemoteDir := filepath.Join(testPath, "actual_remote")
expectedRemoteDir := filepath.Join(testPath, "expected_remote")
2022-01-28 12:56:01 +02:00
otherRepoDir := filepath.Join(testPath, "other_repo")
logf("path: %s", testPath)
2021-04-06 01:02:01 +02:00
for i, speed := range speeds {
if mode != SANDBOX && mode != RECORD {
logf("%s: attempting test at speed %f\n", test.Name, speed)
}
2021-04-06 01:02:01 +02:00
findOrCreateDir(testPath)
2021-10-22 11:18:40 +02:00
prepareIntegrationTestDir(actualRepoDir)
2022-01-28 12:56:01 +02:00
removeDir(otherRepoDir)
removeDir(actualRemoteDir)
2021-10-22 11:18:40 +02:00
err := createFixture(testPath, actualRepoDir)
2021-04-06 01:02:01 +02:00
if err != nil {
return err
}
configDir := filepath.Join(testPath, "used_config")
cmd, err := getLazygitCommand(testPath, rootDir, mode, speed, test.ExtraCmdArgs)
2021-04-06 01:02:01 +02:00
if err != nil {
return err
}
err = runCmd(cmd)
if err != nil {
return err
}
2022-01-28 12:56:01 +02:00
// submodule tests currently make use of a repo called 'other_repo' but we don't want that
// to stick around. Long-term we should have an 'actual' folder which itself contains
// repos, and there we can put the 'repo' repo which is the main one, alongside
// any others that we use as part of the test (including remotes). Then we'll do snapshots for
// each of them.
removeDir(otherRepoDir)
if mode == UPDATE_SNAPSHOT || mode == RECORD {
2022-01-28 12:56:01 +02:00
// create/update snapshot
2021-10-22 11:18:40 +02:00
err = oscommands.CopyDir(actualRepoDir, expectedRepoDir)
2021-04-06 01:02:01 +02:00
if err != nil {
return err
}
2022-01-28 12:56:01 +02:00
if err := renameGitDirs(expectedRepoDir); err != nil {
return err
}
2021-10-22 11:18:40 +02:00
// see if we have a remote dir and if so, copy it over. Otherwise, delete the expected dir because we have no remote folder.
if folderExists(actualRemoteDir) {
err = oscommands.CopyDir(actualRemoteDir, expectedRemoteDir)
if err != nil {
return err
}
} else {
2022-01-28 12:56:01 +02:00
removeDir(expectedRemoteDir)
2021-10-22 11:18:40 +02:00
}
2021-04-06 01:02:01 +02:00
2022-01-28 12:56:01 +02:00
logf("%s", "updated snapshot")
} else {
// compare result to snapshot
actualRepo, expectedRepo, err := generateSnapshots(actualRepoDir, expectedRepoDir)
2021-10-22 11:18:40 +02:00
if err != nil {
return err
}
actualRemote := "remote folder does not exist"
expectedRemote := "remote folder does not exist"
if folderExists(expectedRemoteDir) {
actualRemote, expectedRemote, err = generateSnapshotsForRemote(actualRemoteDir, expectedRemoteDir)
if err != nil {
return err
}
} else if folderExists(actualRemoteDir) {
actualRemote = "remote folder exists"
}
2021-04-06 01:02:01 +02:00
if expectedRepo == actualRepo && expectedRemote == actualRemote {
logf("%s: success at speed %f\n", test.Name, speed)
break
2021-04-06 01:02:01 +02:00
}
2022-01-28 12:56:01 +02:00
// if the snapshot doesn't match and we haven't tried all playback speeds different we'll retry at a slower speed
if i == len(speeds)-1 {
// get the log file and print that
bytes, err := ioutil.ReadFile(filepath.Join(configDir, "development.log"))
if err != nil {
return err
}
logf("%s", string(bytes))
if expectedRepo != actualRepo {
onFail(t, expectedRepo, actualRepo, "repo")
} else {
onFail(t, expectedRemote, actualRemote, "remote")
}
2021-10-22 11:18:40 +02:00
}
2021-04-06 01:02:01 +02:00
}
}
return nil
})
}
return nil
}
2022-01-28 12:56:01 +02:00
func removeDir(dir string) {
2021-10-22 11:18:40 +02:00
err := os.RemoveAll(dir)
if err != nil {
panic(err)
}
}
2021-04-06 01:02:01 +02:00
func prepareIntegrationTestDir(actualDir string) {
2021-04-05 12:37:18 +02:00
// remove contents of integration test directory
dir, err := ioutil.ReadDir(actualDir)
if err != nil {
if os.IsNotExist(err) {
err = os.Mkdir(actualDir, 0777)
if err != nil {
panic(err)
}
} else {
panic(err)
}
}
for _, d := range dir {
os.RemoveAll(filepath.Join(actualDir, d.Name()))
}
}
func GetRootDirectory() string {
path, err := os.Getwd()
if err != nil {
panic(err)
}
for {
_, err := os.Stat(filepath.Join(path, ".git"))
if err == nil {
return path
}
if !os.IsNotExist(err) {
panic(err)
}
path = filepath.Dir(path)
if path == "/" {
2022-01-09 05:09:15 +02:00
log.Fatal("must run in lazygit folder or child folder")
2021-04-05 12:37:18 +02:00
}
}
}
2021-04-06 01:02:01 +02:00
func createFixture(testPath, actualDir string) error {
2021-04-05 12:37:18 +02:00
bashScriptPath := filepath.Join(testPath, "setup.sh")
cmd := secureexec.Command("bash", bashScriptPath, actualDir)
2022-01-26 07:46:54 +02:00
if output, err := cmd.CombinedOutput(); err != nil {
return errors.New(string(output))
2021-04-05 12:37:18 +02:00
}
return nil
}
2021-04-06 01:02:01 +02:00
func tempLazygitPath() string {
2021-04-05 12:37:18 +02:00
return filepath.Join("/tmp", "lazygit", "test_lazygit")
}
func getTestSpeeds(testStartSpeed float64, mode Mode, speedStr string) []float64 {
if mode != TEST {
2021-04-05 12:37:18 +02:00
// have to go at original speed if updating snapshots in case we go to fast and create a junk snapshot
return []float64{1.0}
2021-04-05 12:37:18 +02:00
}
2021-04-06 00:18:57 +02:00
if speedStr != "" {
speed, err := strconv.ParseFloat(speedStr, 64)
2021-04-05 12:37:18 +02:00
if err != nil {
panic(err)
}
return []float64{speed}
2021-04-05 12:37:18 +02:00
}
// default is 10, 5, 1
startSpeed := 10.0
2021-04-05 12:37:18 +02:00
if testStartSpeed != 0 {
startSpeed = testStartSpeed
}
speeds := []float64{startSpeed}
2021-04-05 12:37:18 +02:00
if startSpeed > 5 {
speeds = append(speeds, 5)
}
speeds = append(speeds, 1, 1)
2021-04-05 12:37:18 +02:00
return speeds
}
func LoadTests(testDir string) ([]*Test, error) {
paths, err := filepath.Glob(filepath.Join(testDir, "/*/test.json"))
if err != nil {
return nil, err
}
tests := make([]*Test, len(paths))
for i, path := range paths {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
test := &Test{}
err = json.Unmarshal(data, test)
if err != nil {
return nil, err
}
test.Name = strings.TrimPrefix(filepath.Dir(path), testDir+"/")
tests[i] = test
}
return tests, nil
}
2021-04-06 01:02:01 +02:00
func findOrCreateDir(path string) {
2021-04-05 12:37:18 +02:00
_, err := os.Stat(path)
if err != nil {
if os.IsNotExist(err) {
err = os.MkdirAll(path, 0777)
if err != nil {
panic(err)
}
} else {
panic(err)
}
}
}
2022-01-28 12:56:01 +02:00
// note that we don't actually store this snapshot in the lazygit repo.
// Instead we store the whole expected git repo of our test, so that
// we can easily change what we want to compare without needing to regenerate
// snapshots for each test.
2021-04-06 01:02:01 +02:00
func generateSnapshot(dir string) (string, error) {
2021-04-05 12:37:18 +02:00
osCommand := oscommands.NewDummyOSCommand()
_, err := os.Stat(filepath.Join(dir, ".git"))
if err != nil {
return "git directory not found", nil
}
snapshot := ""
cmdStrs := []string{
2022-01-28 12:56:01 +02:00
`status`, // file tree
`log --pretty=%B -p -1`, // log
`tag -n`, // tags
`stash list`, // stash
`submodule foreach 'git status'`, // submodule status
`submodule foreach 'git log --pretty=%B -p -1'`, // submodule log
`submodule foreach 'git tag -n'`, // submodule tags
`submodule foreach 'git stash list'`, // submodule stash
2021-04-05 12:37:18 +02:00
}
for _, cmdStr := range cmdStrs {
// ignoring error for now. If there's an error it could be that there are no results
2022-01-28 12:56:01 +02:00
output, _ := osCommand.Cmd.New(fmt.Sprintf("git -C %s %s", dir, cmdStr)).RunWithOutput()
2021-04-05 12:37:18 +02:00
2022-01-28 12:56:01 +02:00
snapshot += fmt.Sprintf("git %s:\n%s\n", cmdStr, output)
2021-04-05 12:37:18 +02:00
}
2022-01-28 12:56:01 +02:00
snapshot += "files in repo:\n"
2021-04-05 12:37:18 +02:00
err = filepath.Walk(dir, func(path string, f os.FileInfo, err error) error {
if err != nil {
return err
}
if f.IsDir() {
if f.Name() == ".git" {
return filepath.SkipDir
}
return nil
}
bytes, err := ioutil.ReadFile(path)
if err != nil {
return err
}
2022-01-28 12:56:01 +02:00
relativePath, err := filepath.Rel(dir, path)
if err != nil {
return err
}
snapshot += fmt.Sprintf("path: %s\ncontent:\n%s\n", relativePath, string(bytes))
2021-04-05 12:37:18 +02:00
return nil
})
if err != nil {
return "", err
}
return snapshot, nil
}
2021-04-06 01:02:01 +02:00
func generateSnapshots(actualDir string, expectedDir string) (string, string, error) {
actual, err := generateSnapshot(actualDir)
2021-04-05 12:37:18 +02:00
if err != nil {
return "", "", err
}
// there are a couple of reasons we're not generating the snapshot in expectedDir directly:
// Firstly we don't want to have to revert our .git file back to .git_keep.
// Secondly, the act of calling git commands like 'git status' actually changes the index
// for some reason, and we don't want to leave your lazygit working tree dirty as a result.
expectedDirCopyDir := filepath.Join(filepath.Dir(expectedDir), "expected_dir_test")
err = oscommands.CopyDir(expectedDir, expectedDirCopyDir)
if err != nil {
return "", "", err
}
2021-04-05 12:37:18 +02:00
if err := restoreGitDirs(expectedDirCopyDir); err != nil {
return "", "", err
}
expected, err := generateSnapshot(expectedDirCopyDir)
if err != nil {
2022-01-28 12:56:01 +02:00
return "", "", err
}
2021-04-05 12:37:18 +02:00
err = os.RemoveAll(expectedDirCopyDir)
2021-04-05 12:37:18 +02:00
if err != nil {
return "", "", err
}
return actual, expected, nil
}
2022-01-28 12:56:01 +02:00
func getPathsToRename(dir string, needle string) []string {
pathsToRename := []string{}
err := filepath.Walk(dir, func(path string, f os.FileInfo, err error) error {
if err != nil {
return err
}
if f.Name() == needle {
pathsToRename = append(pathsToRename, path)
}
return nil
})
if err != nil {
panic(err)
}
return pathsToRename
}
// Git refuses to track .git and .gitmodules folders in subdirectories so we need to rename it
// to git_keep after running a test, and then change it back again
var untrackedGitDirs []string = []string{".git", ".gitmodules"}
func renameGitDirs(dir string) error {
for _, untrackedGitDir := range untrackedGitDirs {
for _, path := range getPathsToRename(dir, untrackedGitDir) {
err := os.Rename(path, path+"_keep")
if err != nil {
return err
}
}
}
return nil
}
func restoreGitDirs(dir string) error {
for _, untrackedGitDir := range untrackedGitDirs {
for _, path := range getPathsToRename(dir, untrackedGitDir+"_keep") {
err := os.Rename(path, strings.TrimSuffix(path, "_keep"))
if err != nil {
return err
}
}
}
return nil
}
2021-10-22 11:18:40 +02:00
func generateSnapshotsForRemote(actualDir string, expectedDir string) (string, string, error) {
actual, err := generateSnapshot(actualDir)
if err != nil {
return "", "", err
}
expected, err := generateSnapshot(expectedDir)
if err != nil {
return "", "", err
}
return actual, expected, nil
}
func getLazygitCommand(testPath string, rootDir string, mode Mode, speed float64, extraCmdArgs string) (*exec.Cmd, error) {
2021-04-05 12:37:18 +02:00
osCommand := oscommands.NewDummyOSCommand()
replayPath := filepath.Join(testPath, "recording.json")
templateConfigDir := filepath.Join(rootDir, "test", "default_test_config")
actualDir := filepath.Join(testPath, "actual")
exists, err := osCommand.FileExists(filepath.Join(testPath, "config"))
if err != nil {
return nil, err
}
if exists {
templateConfigDir = filepath.Join(testPath, "config")
}
configDir := filepath.Join(testPath, "used_config")
err = os.RemoveAll(configDir)
if err != nil {
return nil, err
}
err = oscommands.CopyDir(templateConfigDir, configDir)
if err != nil {
return nil, err
}
cmdStr := fmt.Sprintf("%s -debug --use-config-dir=%s --path=%s %s", tempLazygitPath(), configDir, actualDir, extraCmdArgs)
2021-04-05 12:37:18 +02:00
2021-12-29 05:33:38 +02:00
cmdObj := osCommand.Cmd.New(cmdStr)
2021-12-07 12:59:36 +02:00
cmdObj.AddEnvVars(fmt.Sprintf("SPEED=%f", speed))
2021-04-05 12:37:18 +02:00
switch mode {
case RECORD:
2021-12-07 12:59:36 +02:00
cmdObj.AddEnvVars(fmt.Sprintf("RECORD_EVENTS_TO=%s", replayPath))
case TEST, UPDATE_SNAPSHOT:
2021-12-07 12:59:36 +02:00
cmdObj.AddEnvVars(fmt.Sprintf("REPLAY_EVENTS_FROM=%s", replayPath))
2021-04-05 12:37:18 +02:00
}
2021-12-07 12:59:36 +02:00
return cmdObj.GetCmd(), nil
2021-04-05 12:37:18 +02:00
}
2021-10-22 11:18:40 +02:00
func folderExists(path string) bool {
_, err := os.Stat(path)
return err == nil
}