Files
Mathias Fredriksson cc76b62009 refactor!: drop edit_files search/replace wire compat (#29221)
Remove the deprecated `search`/`replace` keys from the `edit_files`
wire type. `FileEdit` now encodes and decodes `old_text`/`new_text`
only; the shims that carried the old keys through the rename (#28467)
are gone.

**Breaking change:** chat lifecycle hook consumers must use `old_text`
and `new_text` for `edit_files`. A `pre_tool_use` `input_override`
that still sends `search`/`replace` fails with `old_text must not be
empty`.

Fixes CODAGT-483
2026-10-06 10:42:44 +00:00

163 lines
5.1 KiB
Go

package workspacesdk_test
import (
"context"
"encoding/json"
"fmt"
"net"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/xerrors"
"tailscale.com/net/tsaddr"
"tailscale.com/tailcfg"
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/workspacesdk"
"github.com/coder/coder/v2/tailnet"
"github.com/coder/coder/v2/testutil"
"github.com/coder/websocket"
)
func TestWorkspaceRewriteDERPMap(t *testing.T) {
t.Parallel()
// This test ensures that RewriteDERPMap mutates built-in DERPs with the
// client access URL.
dm := &tailcfg.DERPMap{
Regions: map[int]*tailcfg.DERPRegion{
1: {
EmbeddedRelay: true,
RegionID: 1,
Nodes: []*tailcfg.DERPNode{{
HostName: "bananas.org",
DERPPort: 1,
}},
},
},
}
parsed, err := url.Parse("https://coconuts.org:44558")
require.NoError(t, err)
client := workspacesdk.New(codersdk.New(parsed))
client.RewriteDERPMap(dm)
region := dm.Regions[1]
require.True(t, region.EmbeddedRelay)
require.Len(t, region.Nodes, 1)
node := region.Nodes[0]
require.Equal(t, "coconuts.org", node.HostName)
require.Equal(t, 44558, node.DERPPort)
}
func TestWorkspaceDialerFailure(t *testing.T) {
t.Parallel()
// Setup.
ctx := testutil.Context(t, testutil.WaitShort)
logger := testutil.Logger(t)
// Given: a mock HTTP server which mimicks an unreachable database when calling the coordination endpoint.
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
httpapi.Write(ctx, w, http.StatusInternalServerError, codersdk.Response{
Message: codersdk.DatabaseNotReachable,
Detail: "oops",
})
}))
t.Cleanup(srv.Close)
u, err := url.Parse(srv.URL)
require.NoError(t, err)
// When: calling the coordination endpoint.
dialer := workspacesdk.NewWebsocketDialer(logger, u, &websocket.DialOptions{})
_, err = dialer.Dial(ctx, nil)
// Then: an error indicating a database issue is returned, to conditionalize the behavior of the caller.
require.ErrorIs(t, err, codersdk.ErrDatabaseNotReachable)
}
func TestClient_IsCoderConnectRunning(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
assert.Equal(t, "/api/v2/workspaceagents/connection", r.URL.Path)
httpapi.Write(ctx, rw, http.StatusOK, workspacesdk.AgentConnectionInfo{
HostnameSuffix: "test",
})
}))
defer srv.Close()
apiURL, err := url.Parse(srv.URL)
require.NoError(t, err)
sdkClient := codersdk.New(apiURL)
client := workspacesdk.New(sdkClient)
// Right name, right IP
expectedName := fmt.Sprintf(tailnet.IsCoderConnectEnabledFmtString, "test")
ctxResolveExpected := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP(tsaddr.CoderServiceIPv6().String())},
}})
result, err := client.IsCoderConnectRunning(ctxResolveExpected, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.True(t, result)
// Wrong name
result, err = client.IsCoderConnectRunning(ctxResolveExpected, workspacesdk.CoderConnectQueryOptions{HostnameSuffix: "coder"})
require.NoError(t, err)
require.False(t, result)
// Not found
ctxResolveNotFound := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, err: &net.DNSError{IsNotFound: true}})
result, err = client.IsCoderConnectRunning(ctxResolveNotFound, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
// Some other error
ctxResolverErr := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, err: xerrors.New("a bad thing happened")})
_, err = client.IsCoderConnectRunning(ctxResolverErr, workspacesdk.CoderConnectQueryOptions{})
require.Error(t, err)
// Right name, wrong IP
ctxResolverWrongIP := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP("2001::34")},
}})
result, err = client.IsCoderConnectRunning(ctxResolverWrongIP, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
}
type fakeResolver struct {
t testing.TB
hostMap map[string][]net.IP
err error
}
func (f *fakeResolver) LookupIP(_ context.Context, network, host string) ([]net.IP, error) {
assert.Equal(f.t, "ip6", network)
return f.hostMap[host], f.err
}
// TestFileEdit_JSONIgnoresDeprecatedKeys pins the removal of the
// search/replace wire compatibility: the encoder emits only the
// current keys and the decoder does not read the deprecated ones.
func TestFileEdit_JSONIgnoresDeprecatedKeys(t *testing.T) {
t.Parallel()
data, err := json.Marshal(workspacesdk.FileEdit{OldText: "old", NewText: "new", ReplaceAll: true})
require.NoError(t, err)
require.JSONEq(t, `{"old_text":"old","new_text":"new","replace_all":true}`, string(data))
var got workspacesdk.FileEdit
require.NoError(t, json.Unmarshal([]byte(`{"search":"old","replace":"new"}`), &got))
require.Equal(t, workspacesdk.FileEdit{}, got)
}