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"
|
2021-04-06 07:20:36 +02:00
|
|
|
"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 {
|
2021-04-06 01:25:58 +02:00
|
|
|
Name string `json:"name"`
|
|
|
|
Speed float64 `json:"speed"`
|
|
|
|
Description string `json:"description"`
|
|
|
|
ExtraCmdArgs string `json:"extraCmdArgs"`
|
2021-04-06 10:20:34 +02:00
|
|
|
Skip bool `json:"skip"`
|
2021-04-05 12:37:18 +02:00
|
|
|
}
|
|
|
|
|
2022-01-15 11:24:19 +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,
|
2021-04-06 07:20:36 +02:00
|
|
|
fnWrapper func(test *Test, f func(*testing.T) error),
|
2022-01-15 11:24:19 +02:00
|
|
|
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),
|
2021-04-06 10:20:34 +02:00
|
|
|
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
|
|
|
|
|
2021-04-06 10:20:34 +02:00
|
|
|
if test.Skip && !includeSkipped {
|
|
|
|
logf("skipping test: %s", test.Name)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2021-04-06 07:20:36 +02:00
|
|
|
fnWrapper(test, func(t *testing.T) error {
|
2022-01-15 11:24:19 +02:00
|
|
|
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")
|
2021-04-06 03:17:32 +02:00
|
|
|
logf("path: %s", testPath)
|
2021-04-06 01:02:01 +02:00
|
|
|
|
|
|
|
for i, speed := range speeds {
|
2022-01-15 11:24:19 +02:00
|
|
|
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")
|
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
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)
|
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
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 {
|
2021-04-06 03:17:32 +02:00
|
|
|
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
|
2022-01-15 11:24:19 +02:00
|
|
|
actualRepo, expectedRepo, err := generateSnapshots(actualRepoDir, expectedRepoDir)
|
2021-10-22 11:18:40 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
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
|
|
|
|
2022-01-15 11:24:19 +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-15 11:24:19 +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
|
2022-01-15 11:24:19 +02:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
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
|
2021-04-05 14:18:36 +02:00
|
|
|
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)
|
|
|
|
}
|
2021-04-05 14:18:36 +02:00
|
|
|
return []float64{speed}
|
2021-04-05 12:37:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// default is 10, 5, 1
|
2021-04-05 14:18:36 +02:00
|
|
|
startSpeed := 10.0
|
2021-04-05 12:37:18 +02:00
|
|
|
if testStartSpeed != 0 {
|
|
|
|
startSpeed = testStartSpeed
|
|
|
|
}
|
2021-04-05 14:18:36 +02:00
|
|
|
speeds := []float64{startSpeed}
|
2021-04-05 12:37:18 +02:00
|
|
|
if startSpeed > 5 {
|
|
|
|
speeds = append(speeds, 5)
|
|
|
|
}
|
2022-01-15 11:24:19 +02:00
|
|
|
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 := ""
|
|
|
|
|
2021-04-06 03:17:32 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2021-04-06 03:17:32 +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
|
|
|
|
}
|
|
|
|
|
|
|
|
defer func() {
|
2022-01-28 12:56:01 +02:00
|
|
|
if err := renameGitDirs(expectedDir); err != nil {
|
2021-04-05 12:37:18 +02:00
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2022-01-28 12:56:01 +02:00
|
|
|
if err := restoreGitDirs(expectedDir); err != nil {
|
|
|
|
return "", "", err
|
|
|
|
}
|
2021-04-05 12:37:18 +02:00
|
|
|
|
2021-04-06 01:02:01 +02:00
|
|
|
expected, err := generateSnapshot(expectedDir)
|
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
|
|
|
|
}
|
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2021-04-06 01:25:58 +02:00
|
|
|
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
|
|
|
|
2022-01-15 11:24:19 +02:00
|
|
|
switch mode {
|
|
|
|
case RECORD:
|
2021-12-07 12:59:36 +02:00
|
|
|
cmdObj.AddEnvVars(fmt.Sprintf("RECORD_EVENTS_TO=%s", replayPath))
|
2022-01-15 11:24:19 +02:00
|
|
|
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
|
|
|
|
}
|