test: add generated tests

murrant · murrant · commit 1d5cbef793b7 · 2025-12-05T12:25:55.000-06:00
diff --git a/pkg/integrations/packagist/client_test.go b/pkg/integrations/packagist/client_test.go
@@ -0,0 +1,206 @@
+package packagist
+
+import (
+    "context"
+    "encoding/json"
+    "net/http"
+    "net/http/httptest"
+    "testing"
+    "time"
+)
+
+func TestNewClient(t *testing.T) {
+    c, err := NewClient(time.Hour)
+    if err != nil {
+        t.Fatalf("NewClient failed: %v", err)
+    }
+    if c.baseURL != "https://repo.packagist.org" {
+        t.Errorf("expected base URL %s, got %s", "https://repo.packagist.org", c.baseURL)
+    }
+}
+
+func TestFetchPackage_Success(t *testing.T) {
+    // Build a fake Packagist p2 response
+    vStable := p2Version{
+        Name:        "vendor/package",
+        Version:     "1.2.3",
+        Description: "A great package",
+        Homepage:    "https://example.com",
+        License:     []string{"MIT"},
+        Require: map[string]string{
+            "php":                 ">=8.0",
+            "ext-json":            "*",
+            "lib-icu":            "*",
+            "composer-plugin-api": "^2.0",
+            "composer-runtime-api": "^2.2",
+            "vendor/dep":          "^0.9.0",
+            "noslash":             "1.0.0",
+        },
+        Source: struct{ URL string `json:"url"` }{URL: "git+https://github.com/user/repo.git"},
+        Authors: []struct{ Name string `json:"name"` }{{Name: "  Jane Doe  "}},
+    }
+    vDev := p2Version{Name: "vendor/package", Version: "1.3.0-dev"}
+    payload := p2Response{Packages: map[string][]p2Version{
+        "vendor/package": {vDev, vStable}, // chooseLatestStable should skip dev and pick vStable
+    }}
+
+    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        if r.URL.Path == "/p2/vendor/package.json" {
+            _ = json.NewEncoder(w).Encode(payload)
+            return
+        }
+        w.WriteHeader(http.StatusNotFound)
+    }))
+    defer server.Close()
+
+    c, err := NewClient(time.Hour)
+    if err != nil {
+        t.Fatalf("NewClient error: %v", err)
+    }
+    // Point client to our test server
+    c.baseURL = server.URL
+
+    info, err := c.FetchPackage(context.Background(), "Vendor/Package", true)
+    if err != nil {
+        t.Fatalf("FetchPackage error: %v", err)
+    }
+
+    if info.Name != "vendor/package" {
+        t.Errorf("want name vendor/package, got %s", info.Name)
+    }
+    if info.Version != "1.2.3" {
+        t.Errorf("want version 1.2.3, got %s", info.Version)
+    }
+    if info.Description != "A great package" {
+        t.Errorf("unexpected description: %s", info.Description)
+    }
+    if info.Author != "Jane Doe" {
+        t.Errorf("want author 'Jane Doe', got %q", info.Author)
+    }
+    if info.Repository != "https://github.com/user/repo" {
+        t.Errorf("unexpected repository url: %s", info.Repository)
+    }
+    if info.HomePage != "https://example.com" {
+        t.Errorf("unexpected homepage: %s", info.HomePage)
+    }
+    // Only vendor/dep should survive filtering
+    if len(info.Dependencies) != 1 || info.Dependencies[0] != "vendor/dep" {
+        t.Errorf("unexpected dependencies: %#v", info.Dependencies)
+    }
+}
+
+func TestFetchPackage_NotFound(t *testing.T) {
+    server := httptest.NewServer(http.NotFoundHandler())
+    defer server.Close()
+
+    c, err := NewClient(time.Minute)
+    if err != nil {
+        t.Fatalf("NewClient error: %v", err)
+    }
+    c.baseURL = server.URL
+
+    if _, err := c.FetchPackage(context.Background(), "missing/pkg", true); err == nil {
+        t.Fatalf("expected error for 404, got nil")
+    }
+}
+
+func TestNormalizeName(t *testing.T) {
+    if got := normalizeName("  VenDor/PackAge  "); got != "vendor/package" {
+        t.Errorf("normalizeName unexpected: %q", got)
+    }
+}
+
+func TestNormalizeRepoURL(t *testing.T) {
+    cases := []struct{ in, want string }{
+        {"git+https://github.com/user/repo.git", "https://github.com/user/repo"},
+        {"git://github.com/user/repo.git", "https://github.com/user/repo"},
+        {"git@github.com:user/repo.git", "https://github.com/user/repo"},
+        {"https://github.com/user/repo", "https://github.com/user/repo"},
+        {"", ""},
+    }
+    for _, c := range cases {
+        if got := normalizeRepoURL(c.in); got != c.want {
+            t.Errorf("normalizeRepoURL(%q) = %q, want %q", c.in, got, c.want)
+        }
+    }
+}
+
+func TestFilterComposerDeps(t *testing.T) {
+    in := map[string]string{
+        "php": ">=8.1",
+        "ext-json": "*",
+        "lib-icu": "*",
+        "composer-plugin-api": "^2",
+        "composer-runtime-api": "^2",
+        "vendor/dep1": "^1.0",
+        "Vendor/Dep2": "*",
+        "no/slash?": "1.0", // still has slash, should be included once normalized by caller (function just checks contains "/")
+        "noslash": "*",    // ignored
+    }
+    got := filterComposerDeps(in)
+    // Expect entries with a slash and not platform/composer special ones
+    if _, ok := got["vendor/dep1"]; !ok {
+        t.Errorf("missing vendor/dep1 in %v", got)
+    }
+    if _, ok := got["vendor/dep2"]; !ok {
+        t.Errorf("missing vendor/dep2 in %v", got)
+    }
+    if _, ok := got["php"]; ok {
+        t.Errorf("php should be filtered out")
+    }
+    if _, ok := got["ext-json"]; ok {
+        t.Errorf("ext-json should be filtered out")
+    }
+    if _, ok := got["lib-icu"]; ok {
+        t.Errorf("lib-icu should be filtered out")
+    }
+    if _, ok := got["composer-plugin-api"]; ok {
+        t.Errorf("composer-plugin-api should be filtered out")
+    }
+    if _, ok := got["composer-runtime-api"]; ok {
+        t.Errorf("composer-runtime-api should be filtered out")
+    }
+}
+
+func TestChooseLatestStable(t *testing.T) {
+    versions := []p2Version{
+        {Version: "2-dev"},
+        {Version: "v3"},   // no dot, not chosen by stable rule
+        {Version: "1.5.0"}, // has dot, should be chosen
+    }
+    got := chooseLatestStable(versions)
+    if got.Version != "1.5.0" {
+        t.Errorf("chooseLatestStable = %s", got.Version)
+    }
+
+    // If none match, fall back to first
+    versions = []p2Version{{Version: "dev-main"}, {Version: "v2"}}
+    got = chooseLatestStable(versions)
+    if got.Version != "dev-main" {
+        t.Errorf("chooseLatestStable fallback = %s", got.Version)
+    }
+}
+
+func TestP2Version_UnmarshalJSON(t *testing.T) {
+    // license as string, require as object with non-string values
+    raw := `{
+        "name": "vendor/pkg",
+        "version": "1.0.0",
+        "description": "d",
+        "homepage": "h",
+        "license": "BSD-3-Clause",
+        "require": {"vendor/dep": "^1", "php": ">=8.0", "weird": 5},
+        "source": {"url": "https://example.com/repo.git"},
+        "authors": [{"name": "Ann"}]
+    }`
+    var v p2Version
+    if err := json.Unmarshal([]byte(raw), &v); err != nil {
+        t.Fatalf("unmarshal: %v", err)
+    }
+    if len(v.License) != 1 || v.License[0] != "BSD-3-Clause" {
+        t.Errorf("unexpected license: %#v", v.License)
+    }
+    if v.Require["vendor/dep"] != "^1" || v.Require["php"] != ">=8.0" {
+        t.Errorf("unexpected require: %#v", v.Require)
+    }
+}
diff --git a/pkg/source/php/php_test.go b/pkg/source/php/php_test.go
@@ -0,0 +1,86 @@
+package php
+
+import (
+    "testing"
+    "time"
+
+    "github.com/matzehuels/stacktower/pkg/integrations/packagist"
+)
+
+func TestNewParser(t *testing.T) {
+    p, err := NewParser(time.Minute)
+    if err != nil {
+        t.Fatalf("NewParser error: %v", err)
+    }
+    if p == nil || p.client == nil {
+        t.Fatalf("parser or client is nil")
+    }
+}
+
+func TestPackageInfo_Getters(t *testing.T) {
+    pi := &packageInfo{&packagist.PackageInfo{
+        Name: "vendor/pkg",
+        Version: "1.0.0",
+        Dependencies: []string{"vendor/dep"},
+    }}
+
+    if pi.GetName() != "vendor/pkg" {
+        t.Errorf("GetName = %s", pi.GetName())
+    }
+    if pi.GetVersion() != "1.0.0" {
+        t.Errorf("GetVersion = %s", pi.GetVersion())
+    }
+    deps := pi.GetDependencies()
+    if len(deps) != 1 || deps[0] != "vendor/dep" {
+        t.Errorf("GetDependencies = %#v", deps)
+    }
+}
+
+func TestPackageInfo_ToMetadata(t *testing.T) {
+    pi := &packageInfo{&packagist.PackageInfo{
+        Version: "2.3.4",
+        Description: "desc",
+        License: "MIT",
+        Author: "Jane",
+    }}
+
+    m := pi.ToMetadata()
+    if m["version"].(string) != "2.3.4" {
+        t.Errorf("version missing or wrong: %#v", m)
+    }
+    if m["description"].(string) != "desc" {
+        t.Errorf("description wrong: %#v", m)
+    }
+    if m["license"].(string) != "MIT" {
+        t.Errorf("license wrong: %#v", m)
+    }
+    if m["author"].(string) != "Jane" {
+        t.Errorf("author wrong: %#v", m)
+    }
+}
+
+func TestPackageInfo_ToRepoInfo(t *testing.T) {
+    pi := &packageInfo{&packagist.PackageInfo{
+        Name:    "vendor/pkg",
+        Version: "0.1.0",
+        Repository: "https://github.com/user/repo",
+        HomePage:   "https://example.com",
+    }}
+
+    ri := pi.ToRepoInfo()
+    if ri.Name != "vendor/pkg" || ri.Version != "0.1.0" {
+        t.Errorf("unexpected name/version: %#v", ri)
+    }
+    if ri.ManifestFile != "composer.json" {
+        t.Errorf("unexpected manifest: %s", ri.ManifestFile)
+    }
+    if ri.ProjectURLs["repository"] != "https://github.com/user/repo" {
+        t.Errorf("repo url missing: %#v", ri.ProjectURLs)
+    }
+    if ri.ProjectURLs["homepage"] != "https://example.com" {
+        t.Errorf("homepage url missing: %#v", ri.ProjectURLs)
+    }
+    if ri.HomePage != "https://example.com" {
+        t.Errorf("homepage field wrong: %s", ri.HomePage)
+    }
+}
