mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
Bind provider credentials to canonical or explicitly configured HTTPS origins and preserve that policy across remote consumers. Reject cross-site credentialed reads, linked fallback directories, and discovered-agent writes outside the source; audit staged content before rooted atomic publication. Add boundary regressions, private Git update coverage, stable cross-platform fixtures, and aligned documentation. Verified the integrated main baseline with all executed CI checks passing.
651 lines
19 KiB
Go
651 lines
19 KiB
Go
package search
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/install"
|
|
)
|
|
|
|
func writeTestIndex(t *testing.T, dir, filename, content string) string {
|
|
t.Helper()
|
|
p := filepath.Join(dir, filename)
|
|
if err := os.WriteFile(p, []byte(content), 0644); err != nil {
|
|
t.Fatalf("write %s: %v", filename, err)
|
|
}
|
|
return p
|
|
}
|
|
|
|
func TestSearchFromIndexURL_LocalFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "react-patterns", "description": "React perf", "source": "facebook/react/.claude/skills/react-patterns"},
|
|
{"name": "deploy-helper", "description": "K8s deploy", "source": "gitlab.com/ops/skills/deploy-helper"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("react", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
if results[0].Name != "react-patterns" {
|
|
t.Errorf("name = %q, want react-patterns", results[0].Name)
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_EmptyQuery(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "alpha", "source": "a/b"},
|
|
{"name": "beta", "source": "c/d"},
|
|
{"name": "gamma", "source": "e/f"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 3 {
|
|
t.Fatalf("got %d results, want 3 (all skills)", len(results))
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_MalformedJSON(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{not valid json}`)
|
|
|
|
_, err := SearchFromIndexURL("test", 20, indexPath, install.ParseOptions{})
|
|
if err == nil {
|
|
t.Fatal("expected error for malformed JSON")
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_LimitRespected(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "a", "source": "x/a"},
|
|
{"name": "b", "source": "x/b"},
|
|
{"name": "c", "source": "x/c"},
|
|
{"name": "d", "source": "x/d"},
|
|
{"name": "e", "source": "x/e"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 2, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 2 {
|
|
t.Fatalf("got %d results, want 2 (limited)", len(results))
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_SourcePathJoin(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"sourcePath": "/home/user/skills",
|
|
"skills": [
|
|
{"name": "my-skill", "source": "_team/frontend/my-skill"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
want := filepath.Join("/home/user/skills", "_team/frontend/my-skill")
|
|
if results[0].Source != want {
|
|
t.Errorf("source = %q, want %q", results[0].Source, want)
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_NoSourcePath(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "remote", "source": "github.com/owner/repo/skill"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
if results[0].Source != "github.com/owner/repo/skill" {
|
|
t.Errorf("source = %q, want original", results[0].Source)
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_EmptyURL(t *testing.T) {
|
|
_, err := SearchFromIndexURL("test", 20, "", install.ParseOptions{})
|
|
if err == nil {
|
|
t.Fatal("expected error for empty URL")
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_SkipsEmptyName(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "", "source": "x/y"},
|
|
{"name": "valid", "source": "a/b"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1 (skip empty name)", len(results))
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_RiskFields(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "index.json", `{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "safe-skill", "source": "a/b", "riskScore": 0, "riskLabel": "clean"},
|
|
{"name": "risky-skill", "source": "c/d", "riskScore": 42, "riskLabel": "medium"},
|
|
{"name": "unaudited-skill", "source": "e/f"}
|
|
]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 20, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 3 {
|
|
t.Fatalf("got %d results, want 3", len(results))
|
|
}
|
|
|
|
// Results are sorted by name: risky, safe, unaudited.
|
|
risky := results[0] // risky-skill
|
|
safe := results[1] // safe-skill
|
|
unaud := results[2] // unaudited-skill
|
|
|
|
if risky.Name != "risky-skill" {
|
|
t.Fatalf("expected risky-skill first (sorted), got %q", risky.Name)
|
|
}
|
|
|
|
// safe-skill: riskScore=0, riskLabel=clean
|
|
if safe.RiskScore == nil {
|
|
t.Fatal("safe-skill: riskScore should not be nil")
|
|
}
|
|
if *safe.RiskScore != 0 {
|
|
t.Errorf("safe-skill: riskScore = %d, want 0", *safe.RiskScore)
|
|
}
|
|
if safe.RiskLabel != "clean" {
|
|
t.Errorf("safe-skill: riskLabel = %q, want 'clean'", safe.RiskLabel)
|
|
}
|
|
|
|
// risky-skill: riskScore=42, riskLabel=medium
|
|
if risky.RiskScore == nil {
|
|
t.Fatal("risky-skill: riskScore should not be nil")
|
|
}
|
|
if *risky.RiskScore != 42 {
|
|
t.Errorf("risky-skill: riskScore = %d, want 42", *risky.RiskScore)
|
|
}
|
|
if risky.RiskLabel != "medium" {
|
|
t.Errorf("risky-skill: riskLabel = %q, want 'medium'", risky.RiskLabel)
|
|
}
|
|
|
|
// unaudited-skill: riskScore=nil, riskLabel=""
|
|
if unaud.RiskScore != nil {
|
|
t.Errorf("unaudited-skill: riskScore should be nil, got %d", *unaud.RiskScore)
|
|
}
|
|
if unaud.RiskLabel != "" {
|
|
t.Errorf("unaudited-skill: riskLabel should be empty, got %q", unaud.RiskLabel)
|
|
}
|
|
}
|
|
|
|
func TestSearchIndex_SSHHubRewritesSameHostGitHubDomainPrefix(t *testing.T) {
|
|
doc := &indexDocument{
|
|
Skills: []indexSkill{
|
|
{
|
|
Name: "reviewer",
|
|
Description: "Internal review skill",
|
|
Source: "acme.ghe.com/Org/skills/skills/reviewer",
|
|
},
|
|
},
|
|
}
|
|
|
|
results, err := searchIndex("", 20, doc, hubSourceContext{
|
|
sshUser: "acme",
|
|
sshHost: "acme.ghe.com",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("searchIndex: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
|
|
wantSource := "acme@acme.ghe.com:Org/skills.git//skills/reviewer"
|
|
if results[0].Source != wantSource {
|
|
t.Fatalf("source = %q, want %q", results[0].Source, wantSource)
|
|
}
|
|
if results[0].Owner != "Org" {
|
|
t.Errorf("Owner = %q, want Org", results[0].Owner)
|
|
}
|
|
if results[0].Repo != "skills" {
|
|
t.Errorf("Repo = %q, want skills", results[0].Repo)
|
|
}
|
|
}
|
|
|
|
func TestSearchIndex_SSHHubRewritePreservesSchemePort(t *testing.T) {
|
|
doc := &indexDocument{
|
|
Skills: []indexSkill{
|
|
{
|
|
Name: "reviewer",
|
|
Source: "github.mycompany.com/Org/skills/skills/reviewer",
|
|
},
|
|
},
|
|
}
|
|
|
|
results, err := searchIndex("", 20, doc, hubSourceContextFromURL("ssh://deploy@github.mycompany.com:2222/Org/skills.git//hubs/team.json"))
|
|
if err != nil {
|
|
t.Fatalf("searchIndex: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
|
|
wantSource := "ssh://deploy@github.mycompany.com:2222/Org/skills.git//skills/reviewer"
|
|
if results[0].Source != wantSource {
|
|
t.Fatalf("source = %q, want %q", results[0].Source, wantSource)
|
|
}
|
|
}
|
|
|
|
func TestSearchIndex_SSHHubRewriteBoundaries(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
source string
|
|
want string
|
|
}{
|
|
{
|
|
name: "explicit https preserved",
|
|
source: "https://acme.ghe.com/Org/skills/skills/reviewer",
|
|
want: "https://acme.ghe.com/Org/skills/skills/reviewer",
|
|
},
|
|
{
|
|
name: "explicit ssh preserved",
|
|
source: "acme@acme.ghe.com:Org/skills.git//skills/reviewer",
|
|
want: "acme@acme.ghe.com:Org/skills.git//skills/reviewer",
|
|
},
|
|
{
|
|
name: "cross host preserved",
|
|
source: "other.ghe.com/Org/skills/skills/reviewer",
|
|
want: "other.ghe.com/Org/skills/skills/reviewer",
|
|
},
|
|
{
|
|
name: "non github host preserved",
|
|
source: "gitlab.com/ops/skills/deploy-helper",
|
|
want: "gitlab.com/ops/skills/deploy-helper",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
doc := &indexDocument{
|
|
Skills: []indexSkill{{Name: "candidate", Source: tt.source}},
|
|
}
|
|
results, err := searchIndex("", 20, doc, hubSourceContext{
|
|
sshUser: "acme",
|
|
sshHost: "acme.ghe.com",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("searchIndex: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
if results[0].Source != tt.want {
|
|
t.Fatalf("source = %q, want %q", results[0].Source, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexJSON_DoesNotRewriteDomainPrefix(t *testing.T) {
|
|
results, err := SearchFromIndexJSON("", 20, []byte(`{
|
|
"schemaVersion": 1,
|
|
"skills": [
|
|
{"name": "reviewer", "source": "acme.ghe.com/Org/skills/skills/reviewer"}
|
|
]
|
|
}`))
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexJSON: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
want := "acme.ghe.com/Org/skills/skills/reviewer"
|
|
if results[0].Source != want {
|
|
t.Fatalf("source = %q, want %q", results[0].Source, want)
|
|
}
|
|
}
|
|
|
|
func TestIsRelativeSource(t *testing.T) {
|
|
tests := []struct {
|
|
source string
|
|
want bool
|
|
}{
|
|
// Relative paths (should return true)
|
|
{"_team/frontend/skill", true},
|
|
{"my-skill", true},
|
|
{"subdir/skill", true},
|
|
{"owner/repo/path", true}, // No dot in first segment → GitHub shorthand, but still "relative" in index context
|
|
|
|
// Absolute paths (should return false)
|
|
{"/shared/nfs/skills/x", false},
|
|
{"~/skills/x", false},
|
|
|
|
// Remote URLs (should return false)
|
|
{"git@gitlab.com:team/repo.git//x", false},
|
|
{"ssh://git@ghe.corp.com/team/skills.git//x", false},
|
|
{"http://example.com/index.json", false},
|
|
{"https://gitlab.com/team/repo/x", false},
|
|
{"file:///path/x", false},
|
|
|
|
// Domain detection (should return false)
|
|
{"gitlab.com/team/repo/x", false},
|
|
{"bitbucket.org/team/repo/x", false},
|
|
{"gitea.company.com/team/repo/x", false},
|
|
{"github.com/owner/repo/skill", false},
|
|
|
|
// Windows paths (should return false)
|
|
{`C:\skills\foo`, false},
|
|
{`D:/projects/skill`, false},
|
|
{`\\server\share\skills\foo`, false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.source, func(t *testing.T) {
|
|
got := isRelativeSource(tt.source)
|
|
if got != tt.want {
|
|
t.Errorf("isRelativeSource(%q) = %v, want %v", tt.source, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHubURL_GitLabBlob(t *testing.T) {
|
|
in := "https://gitlab.com/runkids/demo_empty/-/blob/b3cc455172bee71af57aff7c5a37fd33d000d3a8/skillshare-hub.json"
|
|
want := "https://gitlab.com/api/v4/projects/runkids%2Fdemo_empty/repository/files/skillshare-hub.json/raw?ref=b3cc455172bee71af57aff7c5a37fd33d000d3a8"
|
|
|
|
got := normalizeHubURL(in)
|
|
if got != want {
|
|
t.Fatalf("normalizeHubURL() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHubURL_GitLabRaw(t *testing.T) {
|
|
in := "https://gitlab.com/runkids/demo_empty/-/raw/main/skillshare-hub.json"
|
|
want := "https://gitlab.com/api/v4/projects/runkids%2Fdemo_empty/repository/files/skillshare-hub.json/raw?ref=main"
|
|
|
|
got := normalizeHubURL(in)
|
|
if got != want {
|
|
t.Fatalf("normalizeHubURL() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHubURL_GitHubBlob(t *testing.T) {
|
|
in := "https://github.com/acme/skills/blob/main/skillshare-hub.json"
|
|
want := "https://raw.githubusercontent.com/acme/skills/main/skillshare-hub.json"
|
|
|
|
got := normalizeHubURL(in)
|
|
if got != want {
|
|
t.Fatalf("normalizeHubURL() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHubURL_BitbucketSrc(t *testing.T) {
|
|
in := "https://bitbucket.org/team/repo/src/main/skillshare-hub.json"
|
|
want := "https://bitbucket.org/team/repo/raw/main/skillshare-hub.json"
|
|
|
|
got := normalizeHubURL(in)
|
|
if got != want {
|
|
t.Fatalf("normalizeHubURL() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeHubURL_BitbucketRaw_NoChange(t *testing.T) {
|
|
in := "https://bitbucket.org/team/repo/raw/main/skillshare-hub.json"
|
|
|
|
got := normalizeHubURL(in)
|
|
if got != in {
|
|
t.Fatalf("normalizeHubURL() = %q, want unchanged %q", got, in)
|
|
}
|
|
}
|
|
|
|
func TestBuildHubRequest_GitLabHeaders(t *testing.T) {
|
|
t.Setenv("GITLAB_TOKEN", "glpat_test")
|
|
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
|
|
|
|
req, err := buildHubRequest("https://gitlab.com/runkids/demo_empty/-/blob/main/skillshare-hub.json", install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildHubRequest() error = %v", err)
|
|
}
|
|
|
|
if !strings.Contains(req.URL.String(), "/api/v4/projects/") {
|
|
t.Fatalf("expected normalized gitlab api URL, got %q", req.URL.String())
|
|
}
|
|
if got := req.Header.Get("PRIVATE-TOKEN"); got != "glpat_test" {
|
|
t.Fatalf("PRIVATE-TOKEN = %q, want glpat_test", got)
|
|
}
|
|
if got := req.Header.Get("Authorization"); got != "Bearer glpat_test" {
|
|
t.Fatalf("Authorization = %q, want Bearer token", got)
|
|
}
|
|
}
|
|
|
|
func TestBuildHubRequest_GitHubHeaders(t *testing.T) {
|
|
t.Setenv("GITHUB_TOKEN", "ghp_test")
|
|
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
|
|
|
|
req, err := buildHubRequest("https://github.com/acme/skills/blob/main/skillshare-hub.json", install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildHubRequest() error = %v", err)
|
|
}
|
|
|
|
if req.URL.Host != "raw.githubusercontent.com" {
|
|
t.Fatalf("request host = %q, want raw.githubusercontent.com", req.URL.Host)
|
|
}
|
|
if got := req.Header.Get("Authorization"); got != "Bearer ghp_test" {
|
|
t.Fatalf("Authorization = %q, want Bearer token", got)
|
|
}
|
|
}
|
|
|
|
func TestBuildHubRequest_BitbucketBasicAuth(t *testing.T) {
|
|
t.Setenv("BITBUCKET_TOKEN", "bb_app_password")
|
|
t.Setenv("BITBUCKET_USERNAME", "willie0903")
|
|
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
|
|
|
|
req, err := buildHubRequest("https://bitbucket.org/team/repo/raw/main/skillshare-hub.json", install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildHubRequest() error = %v", err)
|
|
}
|
|
|
|
user, pass, ok := req.BasicAuth()
|
|
if !ok {
|
|
t.Fatal("expected basic auth to be set for bitbucket request")
|
|
}
|
|
if user != "willie0903" || pass != "bb_app_password" {
|
|
t.Fatalf("basic auth = %q:%q, want willie0903:bb_app_password", user, pass)
|
|
}
|
|
}
|
|
|
|
func TestBuildHubRequest_NoToken_NoAuthHeader(t *testing.T) {
|
|
t.Setenv("GITHUB_TOKEN", "")
|
|
t.Setenv("GITLAB_TOKEN", "")
|
|
t.Setenv("BITBUCKET_TOKEN", "")
|
|
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
|
|
|
|
req, err := buildHubRequest("https://gitlab.com/group/repo/-/raw/main/skillshare-hub.json", install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildHubRequest() error = %v", err)
|
|
}
|
|
|
|
if got := req.Header.Get("Authorization"); got != "" {
|
|
t.Fatalf("Authorization = %q, want empty", got)
|
|
}
|
|
if got := req.Header.Get("PRIVATE-TOKEN"); got != "" {
|
|
t.Fatalf("PRIVATE-TOKEN = %q, want empty", got)
|
|
}
|
|
if _, _, ok := req.BasicAuth(); ok {
|
|
t.Fatal("did not expect basic auth without token")
|
|
}
|
|
}
|
|
|
|
func TestHubHTTPError_AuthHints(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
url string
|
|
status int
|
|
hint string
|
|
}{
|
|
{
|
|
name: "gitlab",
|
|
url: "https://gitlab.com/group/repo/-/raw/main/skillshare-hub.json",
|
|
status: 403,
|
|
hint: "GITLAB_TOKEN",
|
|
},
|
|
{
|
|
name: "github",
|
|
url: "https://raw.githubusercontent.com/acme/skills/main/skillshare-hub.json",
|
|
status: 401,
|
|
hint: "GITHUB_TOKEN",
|
|
},
|
|
{
|
|
name: "bitbucket",
|
|
url: "https://bitbucket.org/team/repo/raw/main/skillshare-hub.json",
|
|
status: 403,
|
|
hint: "BITBUCKET_TOKEN",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := hubHTTPError(tt.url, tt.status)
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error")
|
|
}
|
|
if !strings.Contains(err.Error(), tt.hint) {
|
|
t.Fatalf("error = %q, want hint containing %q", err.Error(), tt.hint)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHubHTTPError_NonAuthStatus(t *testing.T) {
|
|
url := "https://gitlab.com/group/repo/-/raw/main/skillshare-hub.json"
|
|
|
|
// 404: names the cause and includes the URL so the user knows which hub failed.
|
|
err := hubHTTPError(url, 404)
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error")
|
|
}
|
|
for _, want := range []string{"404", "not found", url} {
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("404 error = %q, want substring %q", err.Error(), want)
|
|
}
|
|
}
|
|
|
|
// 400: typically a malformed URL — guide the user toward a raw JSON URL.
|
|
err = hubHTTPError("https://raw.githubusercontent.com/runkids", 400)
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error")
|
|
}
|
|
for _, want := range []string{"400", "skillshare-hub.json"} {
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("400 error = %q, want substring %q", err.Error(), want)
|
|
}
|
|
}
|
|
|
|
// Other statuses still include the code and URL.
|
|
err = hubHTTPError(url, 500)
|
|
if err == nil || !strings.Contains(err.Error(), "500") || !strings.Contains(err.Error(), url) {
|
|
t.Fatalf("500 error = %v, want code and URL", err)
|
|
}
|
|
}
|
|
|
|
func TestSearchFromIndexURL_PinnedSourceKeepsRef(t *testing.T) {
|
|
dir := t.TempDir()
|
|
indexPath := writeTestIndex(t, dir, "skillshare-hub.json", `{
|
|
"skills": [{
|
|
"name": "writing-for-agents",
|
|
"source": "github.com/mattpocock/skills/tree/v1.2.0/skills/productivity/writing-for-agents"
|
|
}]
|
|
}`)
|
|
|
|
results, err := SearchFromIndexURL("", 0, indexPath, install.ParseOptions{})
|
|
if err != nil {
|
|
t.Fatalf("SearchFromIndexURL: %v", err)
|
|
}
|
|
if len(results) != 1 {
|
|
t.Fatalf("got %d results, want 1", len(results))
|
|
}
|
|
|
|
src, err := install.ParseSource(results[0].Source)
|
|
if err != nil {
|
|
t.Fatalf("ParseSource(%q): %v", results[0].Source, err)
|
|
}
|
|
if src.Branch != "v1.2.0" {
|
|
t.Errorf("Branch = %q, want v1.2.0", src.Branch)
|
|
}
|
|
if src.Subdir != "skills/productivity/writing-for-agents" {
|
|
t.Errorf("Subdir = %q", src.Subdir)
|
|
}
|
|
}
|
|
|
|
func TestBuildHubRequest_ConfiguredHostAuthorization(t *testing.T) {
|
|
t.Setenv("CNB_TOKEN", "cnb-test-token")
|
|
t.Setenv("GITEA_TOKEN", "gitea-test-token")
|
|
t.Setenv("SKILLSHARE_GIT_TOKEN", "")
|
|
opts := install.ParseOptions{
|
|
CNBHosts: []string{"cnb.corp.example"},
|
|
GiteaHosts: []string{"forge.corp.example"},
|
|
}
|
|
for _, tt := range []struct {
|
|
url, auth string
|
|
}{
|
|
{"https://cnb.corp.example/org/repo/raw/main/skillshare-hub.json", "Bearer cnb-test-token"},
|
|
{"https://forge.corp.example/org/repo/raw/main/skillshare-hub.json", "Bearer gitea-test-token"},
|
|
{"https://cnb.attacker.invalid/org/repo/raw/main/skillshare-hub.json", ""},
|
|
{"https://gitea.attacker.invalid/org/repo/raw/main/skillshare-hub.json", ""},
|
|
{"https://forge.corp.example.attacker.invalid/org/repo/raw/main/skillshare-hub.json", ""},
|
|
} {
|
|
t.Run(tt.url, func(t *testing.T) {
|
|
req, err := buildHubRequest(tt.url, opts)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := req.Header.Get("Authorization"); got != tt.auth {
|
|
t.Fatalf("Authorization = %q, want %q", got, tt.auth)
|
|
}
|
|
})
|
|
}
|
|
}
|