dimitar
0c9c07e8de
Add the scheduling layer and the watch command so gitflow can rescan
repositories on an interval and surface state changes.
Scheduler (internal/scheduler):
- Scheduler runs a callback immediately and then on a time.Ticker until
the context is cancelled; interval <= 0 means a single run
- Graceful shutdown: cancellation is never reported as an error (checked
on the first run and after every run), so Ctrl-C / SIGTERM exit cleanly
- A non-cancellation run error stops the loop and is propagated
Change detection (pkg/status):
- Changed(prev, next) compares snapshots per repository path — status,
branch, detached flag, ahead/behind, stash count, and file counts —
and returns the repositories whose observable state differs, including
repositories that newly appear
Watch command (cmd/gitflow):
- newWatchCmd validates that --interval is positive, prompts for the
parent directory on a TTY when --dir is absent, and drives the
scheduler with ScanOnce
- Each frame clears the screen on a terminal (or prints a RFC3339 header
when output is piped, so watch doubles as a lightweight logger) and
renders through the presenter
- Footer shows changed repositories since the previous frame ("▲ name:
status") and the next scan time; JSON format emits one document per
frame for scripting
- SIGINT/SIGTERM handled via signalContext for a clean stop
Testing:
- Scheduler: single run, periodic repetition, stop-on-error, pre-cancelled
context, and cancellation-during-run (no error reported)
- status.Changed: unchanged repos ignored; status, file-count, and
newly-appeared repos detected
Verified: go build, go vet, go test -race, gofmt clean; manual watch
smoke test over a scratch directory with 1s interval — frames render,
SIGINT and SIGTERM both exit 0 with no orphaned processes.
96 lines
2.2 KiB
Go
96 lines
2.2 KiB
Go
package scheduler
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestRunOnce(t *testing.T) {
|
|
var calls atomic.Int32
|
|
s := New(0, func(ctx context.Context) error {
|
|
calls.Add(1)
|
|
return nil
|
|
})
|
|
if err := s.Run(context.Background()); err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if got := calls.Load(); got != 1 {
|
|
t.Errorf("run called %d times, want 1", got)
|
|
}
|
|
}
|
|
|
|
func TestRunPeriodic(t *testing.T) {
|
|
var calls atomic.Int32
|
|
s := New(10*time.Millisecond, func(ctx context.Context) error {
|
|
calls.Add(1)
|
|
return nil
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan error, 1)
|
|
go func() { done <- s.Run(ctx) }()
|
|
|
|
time.Sleep(55 * time.Millisecond)
|
|
cancel()
|
|
if err := <-done; err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if got := calls.Load(); got < 3 {
|
|
t.Errorf("run called %d times, want >= 3", got)
|
|
}
|
|
}
|
|
|
|
func TestRunStopsOnError(t *testing.T) {
|
|
var calls atomic.Int32
|
|
wantErr := errors.New("boom")
|
|
s := New(5*time.Millisecond, func(ctx context.Context) error {
|
|
n := calls.Add(1)
|
|
if n == 2 {
|
|
return wantErr
|
|
}
|
|
return nil
|
|
})
|
|
if err := s.Run(context.Background()); !errors.Is(err, wantErr) {
|
|
t.Fatalf("Run() error = %v, want %v", err, wantErr)
|
|
}
|
|
if got := calls.Load(); got != 2 {
|
|
t.Errorf("run called %d times, want 2", got)
|
|
}
|
|
}
|
|
|
|
func TestRunCancelledBeforeStart(t *testing.T) {
|
|
var calls atomic.Int32
|
|
s := New(time.Second, func(ctx context.Context) error {
|
|
calls.Add(1)
|
|
return nil
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if err := s.Run(ctx); err != nil {
|
|
t.Fatalf("Run: %v", err)
|
|
}
|
|
if got := calls.Load(); got != 0 {
|
|
t.Errorf("run called %d times, want 0", got)
|
|
}
|
|
}
|
|
|
|
func TestRunCancellationIsNotAnError(t *testing.T) {
|
|
var calls atomic.Int32
|
|
s := New(5*time.Millisecond, func(ctx context.Context) error {
|
|
calls.Add(1)
|
|
time.Sleep(50 * time.Millisecond) // outlive cancellation
|
|
return ctx.Err()
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan error, 1)
|
|
go func() { done <- s.Run(ctx) }()
|
|
|
|
time.Sleep(12 * time.Millisecond)
|
|
cancel()
|
|
if err := <-done; err != nil {
|
|
t.Fatalf("Run returned %v on cancellation, want nil", err)
|
|
}
|
|
}
|