Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 13 additions & 6 deletions cmd/internal/agentworkspace/up.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
177 changes: 177 additions & 0 deletions cmd/internal/agentworkspace/up_test.go
Original file line number Diff line number Diff line change
@@ -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"

Expand Down
48 changes: 32 additions & 16 deletions pkg/http/stall_test.go
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
package http

import (
"context"
"errors"
"io"
"net/http"
Expand All @@ -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)
}
Expand All @@ -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) {
Expand Down
Loading