package server import ( "os" "os/exec" "path/filepath" "strings" "testing" "skillshare/internal/config" ) // initGitRepo creates a minimal git repo with an initial commit. func initGitRepo(t *testing.T, dir string) { t.Helper() for _, args := range [][]string{ {"init"}, {"config", "user.email", "test@test.com"}, {"config", "user.name", "Test"}, } { cmd := exec.Command("git", args...) cmd.Dir = dir if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %v failed: %s %v", args, out, err) } } // Create initial commit f := filepath.Join(dir, "README.md") os.WriteFile(f, []byte("# init"), 0644) for _, args := range [][]string{ {"add", "."}, {"commit", "-m", "init"}, } { cmd := exec.Command("git", args...) cmd.Dir = dir if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %v failed: %s %v", args, out, err) } } } func TestUpdateSingle_NestedTrackedRepo_Resolves(t *testing.T) { s, src := newTestServer(t) // Create a nested tracked repo with a real git init repoDir := filepath.Join(src, "org", "_team-skills") os.MkdirAll(repoDir, 0755) initGitRepo(t, repoDir) result := s.updateSingle("org/_team-skills", false, true) // Should resolve (may be up-to-date or updated, but NOT "error"/"not found") if result.Action == "error" && strings.Contains(result.Message, "not found") { t.Fatalf("updateSingle failed to resolve nested repo: %s", result.Message) } } func TestUpdateSingle_BasenameFallback(t *testing.T) { s, src := newTestServer(t) // Create a top-level tracked repo with _ prefix repoDir := filepath.Join(src, "_team-skills") os.MkdirAll(repoDir, 0755) initGitRepo(t, repoDir) // Call with unprefixed basename — should resolve to _team-skills result := s.updateSingle("team-skills", false, true) if result.Action == "error" && strings.Contains(result.Message, "not found") { t.Fatalf("updateSingle failed to resolve basename: %s", result.Message) } if result.Name != "_team-skills" && result.Name != "team-skills" { // Name should reflect the resolved repo t.Logf("resolved name: %s, action: %s", result.Name, result.Action) } } func TestUpdateSingle_NotFound(t *testing.T) { s, _ := newTestServer(t) result := s.updateSingle("nonexistent-repo", false, true) if result.Action != "error" { t.Fatalf("expected action=error for not-found, got %q", result.Action) } if !strings.Contains(result.Message, "not found") && !strings.Contains(result.Message, "no update source") { t.Fatalf("expected not-found message, got %q", result.Message) } } func TestUpdateSingle_RegularSkillPriority(t *testing.T) { s, src := newTestServer(t) // Create both a regular skill with meta AND a tracked repo with _ prefix skillDir := filepath.Join(src, "my-skill") os.MkdirAll(skillDir, 0755) os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: my-skill\n---\n# Skill"), 0644) addSkillMeta(t, src, "my-skill", "https://github.com/example/my-skill") repoDir := filepath.Join(src, "_my-skill") os.MkdirAll(repoDir, 0755) initGitRepo(t, repoDir) // updateSingle("my-skill") should try regular skill first (has meta). // It will fail to clone (fake URL) but the point is it chose the skill path, // not the tracked repo path. A "not found" would mean it tried the repo instead. result := s.updateSingle("my-skill", false, true) // The error should be about cloning (skill path), not "not found" (repo path) if result.Action == "error" && strings.Contains(result.Message, "not found") && !strings.Contains(result.Message, "clone") { t.Fatalf("expected regular skill to be tried first, got repo-like not-found: %s", result.Message) } } func TestAuditGateTrackedRepo_RollbackFailure_ReportsWarning(t *testing.T) { // Create a git repo with a HIGH-severity finding repoDir := t.TempDir() initGitRepo(t, repoDir) // Add a file that triggers a HIGH finding (prompt injection in HTML comment) malicious := filepath.Join(repoDir, "SKILL.md") os.WriteFile(malicious, []byte("# Skill\n\n"), 0644) for _, args := range [][]string{ {"add", "."}, {"commit", "-m", "add malicious content"}, } { cmd := exec.Command("git", args...) cmd.Dir = repoDir if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %v failed: %s %v", args, out, err) } } // Create a minimal server cfg := &config.Config{ Source: t.TempDir(), Audit: config.AuditConfig{BlockThreshold: "HIGH"}, } s := &Server{cfg: cfg} // Pass an invalid beforeHash so git reset --hard will fail result, _ := s.auditGateTrackedRepo("test-repo", repoDir, "0000000000000000000000000000000000000000", s.updateAuditThreshold()) if result == nil { t.Fatal("expected blocked result, got nil (audit should detect HIGH finding)") } if result.Action != "blocked" { t.Errorf("expected action=blocked, got %q", result.Action) } if !strings.Contains(result.Message, "rollback") { t.Errorf("expected rollback mention in message, got %q", result.Message) } if !strings.Contains(result.Message, "WARNING") { t.Errorf("expected WARNING about failed rollback, got %q", result.Message) } if !strings.Contains(result.Message, "malicious content may remain") { t.Errorf("expected 'malicious content may remain' warning, got %q", result.Message) } } func TestAuditGateTrackedRepo_ScanError_RollbackFailure_ReportsWarning(t *testing.T) { cfg := &config.Config{Source: t.TempDir()} s := &Server{cfg: cfg} // Non-existent path → audit.ScanSkill returns error, git.ResetHard also fails nonExistentPath := filepath.Join(t.TempDir(), "does-not-exist") result, _ := s.auditGateTrackedRepo("test-repo", nonExistentPath, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", s.updateAuditThreshold()) if result == nil { t.Fatal("expected blocked result") } if result.Action != "blocked" { t.Errorf("expected action=blocked, got %q", result.Action) } if !strings.Contains(result.Message, "security audit failed") { t.Errorf("expected 'security audit failed' in message, got %q", result.Message) } if !strings.Contains(result.Message, "WARNING") { t.Errorf("expected WARNING in message, got %q", result.Message) } if !strings.Contains(result.Message, "malicious content may remain") { t.Errorf("expected 'malicious content may remain' warning, got %q", result.Message) } } func TestAuditGateTrackedRepo_Clean_ReturnsNil(t *testing.T) { repoDir := t.TempDir() initGitRepo(t, repoDir) // Only clean content — no findings os.WriteFile(filepath.Join(repoDir, "SKILL.md"), []byte("# A clean skill\nJust helpful instructions.\n"), 0644) for _, args := range [][]string{ {"add", "."}, {"commit", "-m", "clean"}, } { cmd := exec.Command("git", args...) cmd.Dir = repoDir cmd.CombinedOutput() } cfg := &config.Config{Source: t.TempDir()} s := &Server{cfg: cfg} blocked, auditResult := s.auditGateTrackedRepo("clean-repo", repoDir, "doesntmatter", s.updateAuditThreshold()) if blocked != nil { t.Errorf("expected nil for clean repo, got action=%q message=%q", blocked.Action, blocked.Message) } if auditResult == nil { t.Fatal("expected audit result for clean repo") } if auditResult.RiskLabel != "clean" { t.Errorf("expected riskLabel=clean, got %q", auditResult.RiskLabel) } }