test: verify integrated repository contracts

Author: santoshkumarradha

control-plane/internal/skillkit/reconcile_test.go

@@ -393,6 +393,60 @@ func TestInstallStopsBeforeCanonicalMutationWhenRecordedPathCleanupFails(t *test
 	}
 }
 
+func TestPublicOperationsStopBeforeCanonicalMutationWhenFilesystemCleanupFails(t *testing.T) {
+	for _, op := range []struct {
+		name string
+		run  func() error
+	}{
+		{"install", func() error {
+			_, err := Install(InstallOptions{SkillName: "agentfield", Targets: []string{"codex"}, Force: true})
+			return err
+		}},
+		{"install-all", func() error {
+			_, err := InstallAll(InstallOptions{Targets: []string{"codex"}, Force: true})
+			return err
+		}},
+		{"update", func() error {
+			_, err := Update("agentfield")
+			return err
+		}},
+	} {
+		t.Run(op.name, func(t *testing.T) {
+			aliasPath := filepath.Join(t.TempDir(), "legacy-integration")
+			if err := os.WriteFile(aliasPath, []byte("legacy"), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			state := reconciliationState(map[string]InstalledTarget{
+				"claude-code": {Method: "symlink", Path: aliasPath},
+			})
+			if op.name == "update" {
+				state.Skills["agentfield"] = InstalledSkill{Targets: map[string]InstalledTarget{
+					"codex": {Method: "marker-block", Path: filepath.Join(t.TempDir(), "codex.md")},
+				}}
+			}
+			home := setupReconciliation(t, state)
+			oldRemove := reconcileRemove
+			reconcileRemove = func(string) error { return errors.New("forced filesystem remove failure") }
+			t.Cleanup(func() { reconcileRemove = oldRemove })
+
+			err := op.run()
+			if err == nil || !strings.Contains(err.Error(), legacyBuilder) || !strings.Contains(err.Error(), "claude-code") {
+				t.Fatalf("%s error = %v, want orphan and target", op.name, err)
+			}
+			if _, err := os.Lstat(filepath.Join(home, "skills", "agentfield")); !os.IsNotExist(err) {
+				t.Fatalf("%s mutated canonical skill before filesystem cleanup failure: %v", op.name, err)
+			}
+			got, err := LoadState()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, ok := got.Skills[legacyBuilder]; !ok {
+				t.Fatalf("%s removed retryable orphan state after filesystem cleanup failure", op.name)
+			}
+		})
+	}
+}
+
 func TestPublicOperationsStopBeforeCanonicalMutationOnUnsupportedOrphan(t *testing.T) {
 	for _, op := range []struct {
 		name string

control-plane/internal/skillkit/skill_mirror_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io/fs"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
@@ -77,6 +78,29 @@ func TestDeprecatedBuilderAliasRemainsOnlyAnAlias(t *testing.T) {
 	}
 }
 
+// Keep the repository's generation check executable from the Go suite as well
+// as comparing the resulting trees above. This catches a future mismatch
+// between the catalog's shipped skills and the sync script's mirror list.
+func TestEmbeddedSkillSyncCheck(t *testing.T) {
+	bash, err := exec.LookPath("bash")
+	if err != nil {
+		t.Skipf("bash unavailable; sync checker is exercised in Bash-capable CI: %v", err)
+	}
+	repoRoot := filepath.Dir(filepath.Dir(skillSourceDirectory(t, "agentfield")))
+	command := exec.Command(bash, "scripts/sync-embedded-skills.sh", "--check")
+	command.Dir = repoRoot
+	output, err := command.CombinedOutput()
+	if err != nil {
+		if strings.Contains(string(output), "execvpe(/bin/bash) failed") {
+			t.Skipf("Bash launcher is present but its WSL runtime is unavailable; sync checker is exercised in Bash-capable CI: %s", output)
+		}
+		t.Fatalf("scripts/sync-embedded-skills.sh --check failed: %v\n%s", err, output)
+	}
+	if !strings.Contains(string(output), "All embedded skills are in sync with sources.") {
+		t.Fatalf("scripts/sync-embedded-skills.sh --check output = %q, want success confirmation", output)
+	}
+}
+
 func skillSourceDirectory(t *testing.T, name string) string {
 	t.Helper()
 	_, file, _, ok := runtime.Caller(0)

control-plane/internal/templates/rendered_manifest_test.go

@@ -132,3 +132,43 @@ func TestRenderedScaffoldManifestRejectsEmptyNodeID(t *testing.T) {
 		t.Fatal("ParsePackageMetadata accepted an empty rendered node ID")
 	}
 }
+
+// String template values may come from user-entered project metadata. Exercise
+// control characters as well as punctuation so the YAML quoting helper cannot
+// accidentally turn a newline or tab into YAML structure.
+func TestRenderedScaffoldManifestEscapesControlCharacters(t *testing.T) {
+	data := TemplateData{
+		ProjectName: "project: first line\nsecond line # &",
+		NodeID:      "control-character-node",
+		AuthorName:  "Author\t\"quoted\"",
+		AgentPort:   1,
+	}
+
+	for _, language := range GetSupportedLanguages() {
+		t.Run(language, func(t *testing.T) {
+			tmpl, err := GetTemplate(language + "/agentfield-package.yaml.tmpl")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var rendered bytes.Buffer
+			if err := tmpl.Execute(&rendered, data); err != nil {
+				t.Fatal(err)
+			}
+
+			dir := t.TempDir()
+			if err := os.WriteFile(filepath.Join(dir, "agentfield-package.yaml"), rendered.Bytes(), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			metadata, err := packages.ParsePackageMetadata(dir)
+			if err != nil {
+				t.Fatalf("ParsePackageMetadata: %v\n%s", err, rendered.String())
+			}
+			if metadata.Author != data.AuthorName {
+				t.Errorf("author = %q, want %q", metadata.Author, data.AuthorName)
+			}
+			if !strings.Contains(metadata.Description, data.ProjectName) {
+				t.Errorf("description = %q, want it to retain %q", metadata.Description, data.ProjectName)
+			}
+		})
+	}
+}