From afe763a7cacb5d432df254b255231faa39227fac Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 18:03:08 -0600 Subject: [PATCH 1/2] refactor(agentworkspace): isolate status lifecycle wrapper --- cmd/internal/agentworkspace/up.go | 19 ++- cmd/internal/agentworkspace/up_test.go | 177 +++++++++++++++++++++++++ 2 files changed, 190 insertions(+), 6 deletions(-) diff --git a/cmd/internal/agentworkspace/up.go b/cmd/internal/agentworkspace/up.go index 4947b0878a..4dab6692cd 100644 --- a/cmd/internal/agentworkspace/up.go +++ b/cmd/internal/agentworkspace/up.go @@ -572,15 +572,22 @@ func prepareWorkspace(ctx context.Context, params prepareWorkspaceParams) error case params.workspaceInfo.CLIOptions.Recreate: phase = status.PhaseRebuildingWorkspace } - if phase == "" || params.reporter == nil { + return prepareWorkspaceWithStatus(ctx, params.reporter, phase, func(ctx context.Context) error { return prepareWorkspaceSource(ctx, params, exists) + }) +} + +func prepareWorkspaceWithStatus( + ctx context.Context, + reporter status.Reporter, + phase status.Phase, + prepare func(context.Context) error, +) error { + if phase == "" || reporter == nil { + return prepare(ctx) } - return status.Run(ctx, params.reporter, status.Operation{ - Phase: phase, - }, func(ctx context.Context) error { - return prepareWorkspaceSource(ctx, params, exists) - }) + return status.Run(ctx, reporter, status.Operation{Phase: phase}, prepare) } // prepareWorkspaceSource dispatches on the workspace source type (git, local diff --git a/cmd/internal/agentworkspace/up_test.go b/cmd/internal/agentworkspace/up_test.go index 0b1f7de9e5..da40db96b7 100644 --- a/cmd/internal/agentworkspace/up_test.go +++ b/cmd/internal/agentworkspace/up_test.go @@ -1,12 +1,189 @@ package agentworkspace import ( + "context" "errors" + "os" + "path/filepath" "testing" + "github.com/devsy-org/devsy/pkg/agent/tunnelserver" "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/status" ) +type workspaceTestLogger struct{} + +func (workspaceTestLogger) Debugf(string, ...any) {} +func (workspaceTestLogger) Info(...any) {} +func (workspaceTestLogger) Infof(string, ...any) {} +func (workspaceTestLogger) Warnf(string, ...any) {} + +var _ tunnelserver.Logger = workspaceTestLogger{} + +func TestPrepareWorkspaceWithStatusCallsPreparationDirectly(t *testing.T) { + assertWorkspacePreparationRunsDirectly(t, status.NewMemoryReporter(), "") + assertWorkspacePreparationRunsDirectly(t, nil, status.PhaseResettingWorkspace) +} + +func assertWorkspacePreparationRunsDirectly( + t *testing.T, + reporter status.Reporter, + phase status.Phase, +) { + t.Helper() + ctx := context.Background() + called := false + prepare := func(got context.Context) error { + called = true + if got != ctx { + t.Errorf("preparation context = %v, want original context %v", got, ctx) + } + return nil + } + if err := prepareWorkspaceWithStatus(ctx, reporter, phase, prepare); err != nil { + t.Fatalf("prepareWorkspaceWithStatus() error = %v", err) + } + if !called { + t.Fatal("preparation was not called") + } + if memoryReporter, ok := reporter.(*status.MemoryReporter); ok { + if events := memoryReporter.Events(); len(events) != 0 { + t.Fatalf("direct preparation reported status events: %+v", events) + } + } +} + +func TestPrepareWorkspaceWithStatusReportsSuccess(t *testing.T) { + reporter := status.NewMemoryReporter() + called := false + err := prepareWorkspaceWithStatus( + context.Background(), reporter, status.PhaseResettingWorkspace, + func(ctx context.Context) error { + called = true + if status.OperationID(ctx) == "" { + t.Fatal("preparation context has no status operation ID") + } + return nil + }, + ) + if err != nil { + t.Fatalf("prepareWorkspaceWithStatus() error = %v", err) + } + if !called { + t.Fatal("preparation was not called") + } + assertWorkspaceStatusEvents( + t, reporter.Events(), status.PhaseResettingWorkspace, status.StateSucceeded, + ) +} + +func TestPrepareWorkspaceWithStatusReportsFailure(t *testing.T) { + reporter := status.NewMemoryReporter() + prepareErr := errors.New("source preparation failed") + err := prepareWorkspaceWithStatus( + context.Background(), reporter, status.PhaseRebuildingWorkspace, + func(context.Context) error { return prepareErr }, + ) + if !errors.Is(err, prepareErr) { + t.Fatalf("prepareWorkspaceWithStatus() error = %v, want %v", err, prepareErr) + } + assertWorkspaceStatusEvents( + t, reporter.Events(), status.PhaseRebuildingWorkspace, status.StateFailed, + ) +} + +func TestPrepareWorkspaceKeepsInitializationErrorAndResetPrecedence(t *testing.T) { + initErrInfo := &provider.AgentWorkspaceInfo{ + Workspace: &provider.Workspace{}, ContentFolder: "invalid\x00folder", + } + reporter := status.NewMemoryReporter() + if err := prepareWorkspace(context.Background(), prepareWorkspaceParams{ + workspaceInfo: initErrInfo, + reporter: reporter, + }); err == nil { + t.Fatal("prepareWorkspace() returned nil for invalid content folder") + } + if events := reporter.Events(); len(events) != 0 { + t.Fatalf("initialization error reported status events: %+v", events) + } + + contentFolder := t.TempDir() + if err := os.MkdirAll(contentFolder, 0o750); err != nil { + t.Fatalf("MkdirAll() error = %v", err) + } + workspaceInfo := &provider.AgentWorkspaceInfo{ + Workspace: &provider.Workspace{ + Source: provider.WorkspaceSource{Container: "container"}, + }, + ContentFolder: contentFolder, + } + workspaceInfo.CLIOptions.Reset = true + workspaceInfo.CLIOptions.Recreate = true + if err := prepareWorkspace(context.Background(), prepareWorkspaceParams{ + workspaceInfo: workspaceInfo, + logger: workspaceTestLogger{}, + reporter: reporter, + }); err != nil { + t.Fatalf("prepareWorkspace() error = %v", err) + } + assertWorkspaceStatusEvents( + t, reporter.Events(), status.PhaseResettingWorkspace, status.StateSucceeded, + ) +} + +func TestPrepareWorkspaceRewritesPlatformLocalContentFolder(t *testing.T) { + origin := t.TempDir() + expectedContentFolder := filepath.Join(origin, "content") + if err := os.MkdirAll(expectedContentFolder, 0o750); err != nil { + t.Fatalf("MkdirAll() error = %v", err) + } + workspaceInfo := &provider.AgentWorkspaceInfo{ + Workspace: &provider.Workspace{ + Source: provider.WorkspaceSource{LocalFolder: t.TempDir()}, + }, + ContentFolder: filepath.Join(t.TempDir(), "original-content"), + Origin: origin, + } + workspaceInfo.CLIOptions.Platform.Enabled = true + if err := prepareWorkspace(context.Background(), prepareWorkspaceParams{ + workspaceInfo: workspaceInfo, + logger: workspaceTestLogger{}, + }); err != nil { + t.Fatalf("prepareWorkspace() error = %v", err) + } + if workspaceInfo.ContentFolder != expectedContentFolder { + t.Errorf( + "ContentFolder = %q, want platform content folder %q", + workspaceInfo.ContentFolder, expectedContentFolder, + ) + } +} + +func assertWorkspaceStatusEvents( + t *testing.T, + events []status.Event, + phase status.Phase, + finalState status.State, +) { + t.Helper() + if len(events) != 2 { + t.Fatalf("status events = %+v, want started and final", events) + } + if events[0].Phase != phase || events[0].State != status.StateStarted { + t.Errorf( + "start event = %+v, want phase %q and state %q", + events[0], phase, status.StateStarted, + ) + } + if events[1].Phase != phase || events[1].State != finalState { + t.Errorf( + "final event = %+v, want phase %q and state %q", + events[1], phase, finalState, + ) + } +} + func TestWaitForDockerPropagatesResolvedPath(t *testing.T) { const resolvedPath = "/Users/dev/.rd/bin/docker" From 7f6be6d76c4eb34773ebf491a87b4cb082ac0729 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 18:37:55 -0600 Subject: [PATCH 2/2] test(http): make stalled body test deterministic --- pkg/http/stall_test.go | 48 ++++++++++++++++++++++++++++-------------- 1 file changed, 32 insertions(+), 16 deletions(-) diff --git a/pkg/http/stall_test.go b/pkg/http/stall_test.go index 3747229c3f..933592750b 100644 --- a/pkg/http/stall_test.go +++ b/pkg/http/stall_test.go @@ -1,6 +1,7 @@ package http import ( + "context" "errors" "io" "net/http" @@ -20,22 +21,15 @@ func TestNewStallTransportPassthroughWhenDisabled(t *testing.T) { } func TestStallTransportAbortsIdleBody(t *testing.T) { - release := make(chan struct{}) - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusOK) - w.(http.Flusher).Flush() - _, _ = w.Write([]byte("partial")) - w.(http.Flusher).Flush() - select { - case <-r.Context().Done(): - case <-release: - } - })) - defer srv.Close() - defer close(release) - - client := &http.Client{Transport: NewStallTransport(http.DefaultTransport, 50*time.Millisecond)} - resp, err := client.Get(srv.URL) + base := stallTestRoundTripper(func(req *http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: http.StatusOK, + Body: &stallTestBody{ctx: req.Context()}, + Request: req, + }, nil + }) + client := &http.Client{Transport: NewStallTransport(base, 50*time.Millisecond)} + resp, err := client.Get("http://stall.test") if err != nil { t.Fatalf("Get: %v", err) } @@ -47,6 +41,28 @@ func TestStallTransportAbortsIdleBody(t *testing.T) { } } +type stallTestRoundTripper func(*http.Request) (*http.Response, error) + +func (fn stallTestRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { + return fn(req) +} + +type stallTestBody struct { + ctx context.Context + sent bool +} + +func (b *stallTestBody) Read(p []byte) (int, error) { + if !b.sent { + b.sent = true + return copy(p, "partial"), nil + } + <-b.ctx.Done() + return 0, b.ctx.Err() +} + +func (b *stallTestBody) Close() error { return nil } + func TestStallTransportAllowsProgressingBody(t *testing.T) { const body = "steadily-delivered-payload" srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {