ttsc 0.21.0 → 0.23.0

package/internal/lspserver/lsp_project_input_registration_reconciles_rejected_pending_request_test.go

@@ -0,0 +1,268 @@
+package lspserver
+
+import (
+  "bytes"
+  "encoding/json"
+  "path/filepath"
+  "testing"
+)
+
+type mutableProjectInputRegistrationSource struct {
+  NullPluginSource
+  snapshot LSPProjectInputSnapshot
+}
+
+func (s *mutableProjectInputRegistrationSource) ProjectInputs() LSPProjectInputSnapshot {
+  return copyProjectInputSnapshot(s.snapshot)
+}
+
+// TestProjectInputRegistrationReconcilesRejectedPendingRequest verifies
+// rejected dynamic-registration requests cannot strand a newer project-input
+// snapshot.
+//
+// A rejected replacement must preserve the last-good registration while the
+// proxy advances to the latest desired snapshot. Rejected stale cleanup must
+// likewise retain its work without blocking a newer registration or creating a
+// duplicate active registration.
+//
+//  1. Register snapshot A, then leave replacement B pending.
+//  2. Publish C and reject B; assert C registers while A remains active.
+//  3. Register D, leave cleanup of C pending, then publish E and reject cleanup.
+//  4. Assert E registers while the rejected cleanup remains deferred.
+//  5. Publish F and assert retained cleanup completes once before F replaces E.
+func TestProjectInputRegistrationReconcilesRejectedPendingRequest(
+  t *testing.T,
+) {
+  root := t.TempDir()
+  snapshot := func(name string) LSPProjectInputSnapshot {
+    return LSPProjectInputSnapshot{
+      Root: filepath.ToSlash(root),
+      Files: []string{
+        filepath.ToSlash(filepath.Join(root, "docs", name+".md")),
+      },
+    }
+  }
+  source := &mutableProjectInputRegistrationSource{snapshot: snapshot("a")}
+  proxy := NewProxy(ProxyOptions{
+    EditorOut: &bytes.Buffer{},
+    Source:    source,
+  })
+  proxy.projectInputWatchReady = true
+  proxy.projectInputWatchDynamic = true
+  proxy.projectInputWatchRelative = true
+
+  proxy.projectInputsRefreshed()
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  registrationA := proxy.projectInputWatchActive
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    projectInputWatchRegistrationForSnapshot(snapshot("a")).Signature,
+    nil,
+    false,
+  )
+
+  source.snapshot = snapshot("b")
+  proxy.projectInputsRefreshed()
+  source.snapshot = snapshot("c")
+  proxy.projectInputsRefreshed()
+  respondToPendingProjectInputWatchRequest(t, proxy, true, "reject B")
+  if proxy.projectInputWatchActive.ID != registrationA.ID {
+    t.Fatalf(
+      "rejected B replaced last-good A: active = %#v, A = %#v",
+      proxy.projectInputWatchActive,
+      registrationA,
+    )
+  }
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    projectInputWatchRegistrationForSnapshot(snapshot("c")).Signature,
+    nil,
+    true,
+  )
+
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  registrationC := proxy.projectInputWatchActive
+  if registrationC.Signature !=
+    projectInputWatchRegistrationForSnapshot(snapshot("c")).Signature {
+    t.Fatalf("active after C success = %#v", registrationC)
+  }
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    registrationC.Signature,
+    []string{registrationA.ID},
+    true,
+  )
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  assertProjectInputWatchState(t, proxy, registrationC.Signature, nil, false)
+
+  source.snapshot = snapshot("d")
+  proxy.projectInputsRefreshed()
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  registrationD := proxy.projectInputWatchActive
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    registrationD.Signature,
+    []string{registrationC.ID},
+    true,
+  )
+
+  source.snapshot = snapshot("e")
+  proxy.projectInputsRefreshed()
+  respondToPendingProjectInputWatchRequest(
+    t,
+    proxy,
+    true,
+    "reject cleanup C",
+  )
+  if proxy.projectInputWatchActive.ID != registrationD.ID {
+    t.Fatalf(
+      "rejected cleanup replaced last-good D: active = %#v, D = %#v",
+      proxy.projectInputWatchActive,
+      registrationD,
+    )
+  }
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    projectInputWatchRegistrationForSnapshot(snapshot("e")).Signature,
+    []string{registrationC.ID},
+    true,
+  )
+
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  registrationE := proxy.projectInputWatchActive
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    registrationE.Signature,
+    []string{registrationC.ID, registrationD.ID},
+    false,
+  )
+
+  source.snapshot = snapshot("f")
+  proxy.projectInputsRefreshed()
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    projectInputWatchRegistrationForSnapshot(snapshot("f")).Signature,
+    []string{registrationD.ID},
+    true,
+  )
+  if proxy.projectInputWatchActive.ID != registrationE.ID {
+    t.Fatal("retrying cleanup registered F before removing retained C")
+  }
+
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    projectInputWatchRegistrationForSnapshot(snapshot("f")).Signature,
+    nil,
+    true,
+  )
+  if proxy.projectInputWatchActive.ID != registrationE.ID {
+    t.Fatal("retrying cleanup registered F before removing stale D")
+  }
+
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  registrationF := proxy.projectInputWatchActive
+  assertProjectInputWatchState(
+    t,
+    proxy,
+    registrationF.Signature,
+    []string{registrationE.ID},
+    true,
+  )
+  respondToPendingProjectInputWatchRequest(t, proxy, false, "")
+  assertProjectInputWatchState(t, proxy, registrationF.Signature, nil, false)
+
+  if proxy.projectInputWatchRegistrationSequence != 6 {
+    t.Fatalf(
+      "registration attempts = %d, want A through F exactly once",
+      proxy.projectInputWatchRegistrationSequence,
+    )
+  }
+}
+
+func respondToPendingProjectInputWatchRequest(
+  t *testing.T,
+  proxy *Proxy,
+  rejected bool,
+  message string,
+) {
+  t.Helper()
+  proxy.pendingMu.Lock()
+  if len(proxy.pendingClientRequests) != 1 {
+    proxy.pendingMu.Unlock()
+    t.Fatalf(
+      "pending client requests = %d, want 1",
+      len(proxy.pendingClientRequests),
+    )
+  }
+  var rawID json.RawMessage
+  for key := range proxy.pendingClientRequests {
+    rawID = json.RawMessage(key)
+  }
+  proxy.pendingMu.Unlock()
+
+  response := Envelope{
+    JSONRPC: "2.0",
+    ID:      rawID,
+    Result:  json.RawMessage("null"),
+  }
+  if rejected {
+    response.Result = nil
+    response.Error, _ = json.Marshal(map[string]any{
+      "code":    -32603,
+      "message": message,
+    })
+  }
+  if !proxy.handleClientRequestResponse(response) {
+    t.Fatalf("pending client response %s was not handled", rawID)
+  }
+}
+
+func assertProjectInputWatchState(
+  t *testing.T,
+  proxy *Proxy,
+  desiredSignature string,
+  staleIDs []string,
+  pending bool,
+) {
+  t.Helper()
+  proxy.projectInputWatchMu.Lock()
+  defer proxy.projectInputWatchMu.Unlock()
+  if proxy.projectInputWatchDesired.Signature != desiredSignature ||
+    !equalProjectInputWatchIDs(proxy.projectInputWatchStaleIDs, staleIDs) ||
+    proxy.projectInputWatchPending != pending {
+    t.Fatalf(
+      "watch state = {desired:%q active:%#v stale:%#v pending:%v failed:%q retryBlocked:%v}, want desired %q stale %#v pending %v",
+      proxy.projectInputWatchDesired.Signature,
+      proxy.projectInputWatchActive,
+      proxy.projectInputWatchStaleIDs,
+      proxy.projectInputWatchPending,
+      proxy.projectInputWatchFailedSignature,
+      proxy.projectInputWatchUnregisterRetryBlocked,
+      desiredSignature,
+      staleIDs,
+      pending,
+    )
+  }
+}
+
+func equalProjectInputWatchIDs(left []string, right []string) bool {
+  if len(left) != len(right) {
+    return false
+  }
+  for index := range left {
+    if left[index] != right[index] {
+      return false
+    }
+  }
+  return true
+}

package/internal/lspserver/lsp_project_input_registration_shapes_patterns_test.go

@@ -0,0 +1,94 @@
+package lspserver
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectInputRegistrationShapesRelativePatterns verifies exact paths and
+// glob populations become deterministic LSP RelativePatterns without treating
+// literal filename metacharacters as wildcards.
+//
+// Reload directories need two registrations: immediate children carry
+// topology changes, while the exact directory identity carries deletion and
+// replacement when a child-rooted watcher can no longer observe the object.
+//
+//  1. Declare duplicate exact files, portable globs, and one reload directory.
+//  2. Build and index the deduplicated relative-pattern registrations.
+//  3. Assert literals are escaped while portable wildcard segments survive.
+//  4. Assert reload-directory identity and immediate-child patterns both exist.
+//  5. Assert drive and UNC file URIs preserve their authority and escaping.
+func TestProjectInputRegistrationShapesRelativePatterns(t *testing.T) {
+  root := t.TempDir()
+  exact := filepath.Join(
+    root,
+    "docs",
+    "contract *?[v1]{draft} #%25.md",
+  )
+  snapshot := LSPProjectInputSnapshot{
+    Root: filepath.ToSlash(root),
+    Files: []string{
+      filepath.ToSlash(exact),
+      filepath.ToSlash(exact),
+    },
+    Globs: []string{
+      filepath.ToSlash(filepath.Join(root, "api", "**", "*.json")),
+      filepath.ToSlash(filepath.Join(
+        root,
+        "api",
+        "**",
+        "v[12]",
+        "{openapi,swagger}.yaml",
+      )),
+    },
+    ReloadDirectories: []string{
+      filepath.ToSlash(filepath.Join(root, "config-deps")),
+    },
+    ReloadFiles: []string{
+      filepath.ToSlash(exact),
+    },
+  }
+  watchers := projectInputFileWatchers(snapshot)
+  if len(watchers) != 5 {
+    t.Fatalf("watchers = %#v, want 5 deduplicated entries", watchers)
+  }
+
+  byPattern := map[string]projectInputFileWatcher{}
+  for _, watcher := range watchers {
+    if watcher.Kind != watchedFileKindAll {
+      t.Fatalf("watcher kind = %d, want %d", watcher.Kind, watchedFileKindAll)
+    }
+    byPattern[watcher.GlobPattern.Pattern] = watcher
+  }
+  literal := "docs/contract [*][?][[]v1[]][{]draft[}] #%25.md"
+  if watcher, ok := byPattern[literal]; !ok {
+    t.Fatalf("escaped exact pattern missing from %#v", byPattern)
+  } else if watcher.GlobPattern.BaseURI == "" {
+    t.Fatal("exact watcher has an empty base URI")
+  }
+  if watcher, ok := byPattern["api/**/*.json"]; !ok {
+    t.Fatalf("glob pattern missing from %#v", byPattern)
+  } else if watcher.GlobPattern.BaseURI == "" {
+    t.Fatal("glob watcher has an empty base URI")
+  }
+  literalMetacharacters :=
+    "api/**/v[[]12[]]/[{]openapi,swagger[}].yaml"
+  if _, ok := byPattern[literalMetacharacters]; !ok {
+    t.Fatalf("literal glob metacharacters were not escaped in %#v", byPattern)
+  }
+  if _, ok := byPattern["config-deps/*"]; !ok {
+    t.Fatalf("reload-directory child watcher missing from %#v", byPattern)
+  }
+  if _, ok := byPattern["config-deps"]; !ok {
+    t.Fatalf("reload-directory identity watcher missing from %#v", byPattern)
+  }
+
+  if got := projectInputFileURI("C:/Program Files/a#b%25"); got !=
+    "file:///C:/Program%20Files/a%23b%2525" {
+    t.Fatalf("drive URI = %q", got)
+  }
+  if got := projectInputFileURI("//server/share/a b#c"); got !=
+    "file://server/share/a%20b%23c" {
+    t.Fatalf("UNC URI = %q", got)
+  }
+}

package/internal/lspserver/lsp_project_input_watchers_anchor_missing_paths_test.go

@@ -0,0 +1,48 @@
+package lspserver
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectInputWatchersAnchorMissingPaths verifies dynamic registrations use
+// an existing ancestor while retaining the missing path in the glob.
+//
+// Editors cannot reliably root a RelativePattern at a directory that does not
+// exist yet. Anchoring at the physical project lets the registration observe
+// later directory creation without broadening beyond the declared pattern.
+//
+//  1. Declare one exact file and one glob under missing nested directories.
+//  2. Build the client watcher registrations before either directory exists.
+//  3. Assert both use the project URI and preserve their missing path segments.
+func TestProjectInputWatchersAnchorMissingPaths(t *testing.T) {
+  root := t.TempDir()
+  watchers := projectInputFileWatchers(LSPProjectInputSnapshot{
+    Root: root,
+    Files: []string{
+      filepath.Join(root, "docs", "missing", "spec.md"),
+    },
+    Globs: []string{
+      filepath.Join(root, "api", "v1", "**", "*.json"),
+    },
+  })
+  if len(watchers) != 2 {
+    t.Fatalf("watchers = %#v", watchers)
+  }
+  wantBase := projectInputFileURI(root)
+  patterns := map[string]bool{}
+  for _, watcher := range watchers {
+    if watcher.GlobPattern.BaseURI != wantBase {
+      t.Fatalf(
+        "watcher base = %q, want %q",
+        watcher.GlobPattern.BaseURI,
+        wantBase,
+      )
+    }
+    patterns[watcher.GlobPattern.Pattern] = true
+  }
+  if !patterns["docs/missing/spec.md"] ||
+    !patterns["api/v1/**/*.json"] {
+    t.Fatalf("watcher patterns = %#v", patterns)
+  }
+}