support recording sessions for testing purposes

pkg/gui/gui.go

@@ -31,6 +31,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/theme"
 	"github.com/jesseduffield/lazygit/pkg/updates"
 	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/jesseduffield/termbox-go"
 	"github.com/mattn/go-runewidth"
 	"github.com/sirupsen/logrus"
 )
@@ -107,6 +108,16 @@ type Gui struct {
 	showRecentRepos   bool
 	Contexts          ContextTree
 	ViewTabContextMap map[string][]tabContext
+
+	// this array either includes the events that we're recording in this session
+	// or the events we've recorded in a prior session
+	RecordedEvents []RecordedEvent
+	StartTime      time.Time
+}
+
+type RecordedEvent struct {
+	Timestamp int64
+	Event     *termbox.Event
 }
 
 type listPanelState struct {
@@ -399,6 +410,7 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *oscom
 		statusManager:        &statusManager{},
 		viewBufferManagerMap: map[string]*tasks.ViewBufferManager{},
 		showRecentRepos:      showRecentRepos,
+		RecordedEvents:       []RecordedEvent{},
 	}
 
 	gui.resetState()
@@ -417,12 +429,18 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *oscom
 func (gui *Gui) Run() error {
 	gui.resetState()
 
-	g, err := gocui.NewGui(gocui.Output256, OverlappingEdges)
+	recordEvents := recordingEvents()
+
+	g, err := gocui.NewGui(gocui.Output256, OverlappingEdges, recordEvents)
 	if err != nil {
 		return err
 	}
 	defer g.Close()
 
+	if recordEvents {
+		go gui.recordEvents()
+	}
+
 	if gui.State.Modes.Filtering.Active() {
 		gui.State.ScreenMode = SCREEN_HALF
 	} else {
@@ -475,6 +493,9 @@ func (gui *Gui) Run() error {
 // if the error returned from a run is a ErrSubProcess, it runs the subprocess
 // otherwise it handles the error, possibly by quitting the application
 func (gui *Gui) RunWithSubprocesses() error {
+	gui.StartTime = time.Now()
+	go gui.replayRecordedEvents()
+
 	for {
 		gui.stopChan = make(chan struct{})
 		if err := gui.Run(); err != nil {
@@ -497,6 +518,10 @@ func (gui *Gui) RunWithSubprocesses() error {
 					}
 				}
 
+				if err := gui.saveRecordedEvents(); err != nil {
+					return err
+				}
+
 				return nil
 			case gui.Errors.ErrSwitchRepo, gui.Errors.ErrRestart:
 				continue

pkg/gui/recording.go

@@ -0,0 +1,85 @@
+package gui
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"os"
+	"time"
+)
+
+func recordingEvents() bool {
+	return os.Getenv("RECORD_EVENTS") == "true"
+}
+
+func (gui *Gui) timeSinceStart() int64 {
+	return time.Since(gui.StartTime).Milliseconds()
+}
+
+func (gui *Gui) replayRecordedEvents() {
+	if os.Getenv("REPLAY_EVENTS_FROM") == "" {
+		return
+	}
+
+	events, err := gui.loadRecordedEvents()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ticker := time.NewTicker(time.Millisecond)
+	defer ticker.Stop()
+
+	var leeway int64 = 1000
+
+	for _, event := range events {
+		for range ticker.C {
+			now := gui.timeSinceStart() - leeway
+			if gui.g != nil && now >= event.Timestamp {
+				gui.g.ReplayedEvents <- *event.Event
+				break
+			}
+		}
+	}
+}
+
+func (gui *Gui) loadRecordedEvents() ([]RecordedEvent, error) {
+	path := os.Getenv("REPLAY_EVENTS_FROM")
+
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	events := []RecordedEvent{}
+
+	err = json.Unmarshal(data, &events)
+	if err != nil {
+		return nil, err
+	}
+
+	return events, nil
+}
+
+func (gui *Gui) saveRecordedEvents() error {
+	if !recordingEvents() {
+		return nil
+	}
+
+	jsonEvents, err := json.Marshal(gui.RecordedEvents)
+	if err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile("recorded_events.json", jsonEvents, 0600)
+}
+
+func (gui *Gui) recordEvents() {
+	for event := range gui.g.RecordedEvents {
+		recordedEvent := RecordedEvent{
+			Timestamp: gui.timeSinceStart(),
+			Event:     event,
+		}
+
+		gui.RecordedEvents = append(gui.RecordedEvents, recordedEvent)
+	}
+}