Additional tests for 100% coverage

wiebe-vandendriessche · wiebe-vandendriessche · commit b4d1390d48b6 · 2026-01-12T16:23:59.000+01:00
diff --git a/internal/fetcher/model_api_fetcher.go b/internal/fetcher/model_api_fetcher.go
@@ -48,8 +48,9 @@ func (v *BoolOrString) UnmarshalJSON(b []byte) error {
 
 // ModelAPIFetcher fetches model metadata from the Hugging Face Hub API.
 type ModelAPIFetcher struct {
-	Client *http.Client
-	Token  string
+	Client  *http.Client
+	Token   string
+	BaseURL string // optional; defaults to "https://huggingface.co"
 }
 
 // ModelAPIResponse is the decoded response from GET https://huggingface.co/api/models/:id
@@ -83,9 +84,15 @@ func (f *ModelAPIFetcher) Fetch(ctx context.Context, modelID string) (*ModelAPIR
 		client = http.DefaultClient
 	}
 
-	logf(modelID, "GET /api/models/%s", strings.TrimPrefix(strings.TrimSpace(modelID), "/"))
+	trimmedModelID := strings.TrimPrefix(strings.TrimSpace(modelID), "/")
+	logf(modelID, "GET /api/models/%s", trimmedModelID)
 
-	url := fmt.Sprintf("https://huggingface.co/api/models/%s", modelID)
+	baseURL := strings.TrimRight(strings.TrimSpace(f.BaseURL), "/")
+	if baseURL == "" {
+		baseURL = "https://huggingface.co"
+	}
+
+	url := fmt.Sprintf("%s/api/models/%s", baseURL, trimmedModelID)
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return nil, err
diff --git a/internal/fetcher/model_api_fetcher_test.go b/internal/fetcher/model_api_fetcher_test.go
@@ -0,0 +1,254 @@
+package fetcher
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+type roundTripperFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
+
+func rewriteToServer(t *testing.T, srvURL string) http.RoundTripper {
+	t.Helper()
+	u, err := url.Parse(srvURL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+	return roundTripperFunc(func(r *http.Request) (*http.Response, error) {
+		rr := r.Clone(r.Context())
+		rr.URL.Scheme = u.Scheme
+		rr.URL.Host = u.Host
+		rr.Host = u.Host
+		rr.RequestURI = ""
+		return http.DefaultTransport.RoundTrip(rr)
+	})
+}
+
+func TestBoolOrString_UnmarshalJSON(t *testing.T) {
+	t.Run("empty bytes", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte("")); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+		if v.Bool != nil || v.String != nil {
+			t.Fatalf("expected nil fields, got Bool=%v String=%v", v.Bool, v.String)
+		}
+	})
+
+	t.Run("null", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte("null")); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+		if v.Bool != nil || v.String != nil {
+			t.Fatalf("expected nil fields, got Bool=%v String=%v", v.Bool, v.String)
+		}
+	})
+
+	t.Run("string", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte(`" auto "`)); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+		if v.String == nil || *v.String != "auto" {
+			t.Fatalf("expected String=auto, got %v", v.String)
+		}
+		if v.Bool != nil {
+			t.Fatalf("expected Bool=nil, got %v", v.Bool)
+		}
+	})
+
+	t.Run("bool", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte(`true`)); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+		if v.Bool == nil || *v.Bool != true {
+			t.Fatalf("expected Bool=true, got %v", v.Bool)
+		}
+		if v.String != nil {
+			t.Fatalf("expected String=nil, got %v", v.String)
+		}
+	})
+
+	t.Run("invalid string json", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte(`"unterminated`)); err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+	})
+
+	t.Run("invalid bool json", func(t *testing.T) {
+		var v BoolOrString
+		if err := v.UnmarshalJSON([]byte(`notabool`)); err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+	})
+}
+
+func TestFetch_Success_DefaultClientNil_NoToken(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			t.Fatalf("method = %s", r.Method)
+		}
+		if r.URL.Path != "/api/models/my/model" {
+			t.Fatalf("path = %q", r.URL.Path)
+		}
+		if got := r.Header.Get("Accept"); got != "application/json" {
+			t.Fatalf("Accept = %q", got)
+		}
+		if got := r.Header.Get("Authorization"); got != "" {
+			t.Fatalf("Authorization should be empty, got %q", got)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"id":           "my/model",
+			"modelId":      "my/model",
+			"library_name": "transformers",
+			"pipeline_tag": "text-generation",
+			"gated":        "auto",
+		})
+	}))
+	defer srv.Close()
+
+	f := &ModelAPIFetcher{
+		Client:  nil, // cover default-client branch
+		BaseURL: srv.URL,
+	}
+	resp, err := f.Fetch(context.Background(), " /my/model ")
+	if err != nil {
+		t.Fatalf("Fetch error: %v", err)
+	}
+	if resp == nil {
+		t.Fatalf("expected response")
+	}
+	if resp.Gated.String == nil || *resp.Gated.String != "auto" {
+		t.Fatalf("expected gated string auto, got %#v", resp.Gated)
+	}
+}
+
+func TestFetch_SetsAuthorizationHeader_And_TrimsBaseURL(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if got := r.Header.Get("Authorization"); got != "Bearer t0k" {
+			t.Fatalf("Authorization = %q", got)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, `{"id":"x","modelId":"x","gated":true}`)
+	}))
+	defer srv.Close()
+
+	f := &ModelAPIFetcher{
+		BaseURL: srv.URL + "/", // cover TrimRight branch
+		Token:   "  t0k ",
+	}
+	resp, err := f.Fetch(context.Background(), "x")
+	if err != nil {
+		t.Fatalf("Fetch error: %v", err)
+	}
+	if resp.Gated.Bool == nil || *resp.Gated.Bool != true {
+		t.Fatalf("expected gated bool true, got %#v", resp.Gated)
+	}
+}
+
+func TestFetch_Non200(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusForbidden)
+	}))
+	defer srv.Close()
+
+	f := &ModelAPIFetcher{BaseURL: srv.URL}
+	_, err := f.Fetch(context.Background(), "x")
+	if err == nil || !strings.Contains(err.Error(), "status 403") {
+		t.Fatalf("expected status error, got %v", err)
+	}
+}
+
+func TestFetch_DecodeError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, "{") // invalid json
+	}))
+	defer srv.Close()
+
+	f := &ModelAPIFetcher{BaseURL: srv.URL}
+	_, err := f.Fetch(context.Background(), "x")
+	if err == nil {
+		t.Fatalf("expected decode error, got nil")
+	}
+}
+
+func TestFetch_RequestError(t *testing.T) {
+	want := errors.New("boom")
+	f := &ModelAPIFetcher{
+		BaseURL: "http://invalid.local",
+		Client: &http.Client{
+			Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
+				return nil, want
+			}),
+		},
+	}
+	_, err := f.Fetch(context.Background(), "x")
+	if err == nil || !errors.Is(err, want) {
+		t.Fatalf("expected %v, got %v", want, err)
+	}
+}
+
+func TestFetch_DefaultBaseURLBranch_WithoutNetwork(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/models/p/q" {
+			t.Fatalf("path = %q", r.URL.Path)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, `{"id":"p/q","modelId":"p/q","gated":false}`)
+	}))
+	defer srv.Close()
+
+	// BaseURL left empty to cover default-BaseURL branch, but transport rewrites to httptest server.
+	f := &ModelAPIFetcher{
+		BaseURL: "   ",
+		Client:  &http.Client{Transport: rewriteToServer(t, srv.URL)},
+	}
+	resp, err := f.Fetch(context.Background(), "/p/q")
+	if err != nil {
+		t.Fatalf("Fetch error: %v", err)
+	}
+	if resp.Gated.Bool == nil || *resp.Gated.Bool != false {
+		t.Fatalf("expected gated bool false, got %#v", resp.Gated)
+	}
+}
+
+func TestSetLoggerAndLogf_Writes(t *testing.T) {
+	var buf bytes.Buffer
+	SetLogger(&buf)
+	logf("m", "hello %s", "world")
+	if buf.Len() == 0 {
+		t.Fatalf("expected log output")
+	}
+	if !strings.Contains(buf.String(), "hello") {
+		t.Fatalf("expected message to contain %q, got %q", "hello", buf.String())
+	}
+}
+
+func TestFetch_NewRequestError_InvalidBaseURL(t *testing.T) {
+	f := &ModelAPIFetcher{
+		// Invalid host (missing closing bracket) => NewRequestWithContext should error.
+		BaseURL: "http://[::1",
+	}
+	got, err := f.Fetch(context.Background(), "x")
+	if err == nil {
+		t.Fatalf("expected error, got nil")
+	}
+	if got != nil {
+		t.Fatalf("expected nil response, got %#v", got)
+	}
+}
diff --git a/internal/io/io_test.go b/internal/io/io_test.go
@@ -55,6 +55,22 @@ func TestReadBOM_OpenError(t *testing.T) {
 	}
 }
 
+func TestReadBOM_Auto_SelectsJSONByExtension(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "bom.json")
+	if err := os.WriteFile(p, []byte(`{}`), 0o600); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	got, err := ReadBOM(p, "auto")
+	if err != nil {
+		t.Fatalf("ReadBOM(auto): %v", err)
+	}
+	if got == nil {
+		t.Fatalf("expected BOM")
+	}
+}
+
 func TestReadBOM_DecodeError_WhenFormatDoesNotMatchContent(t *testing.T) {
 	dir := t.TempDir()
 	p := filepath.Join(dir, "bom.json")
@@ -180,3 +196,64 @@ func TestWriteBOM_UnsupportedFormat(t *testing.T) {
 		t.Fatalf("expected error for unsupported format")
 	}
 }
+
+func TestWriteBOM_OpenError_WhenOutputIsDirectory(t *testing.T) {
+	dir := t.TempDir()
+
+	// Make a *directory* that still has a valid ".json" extension so we get past
+	// extension validation and hit the os.Create(...) error path.
+	outDir := filepath.Join(dir, "bom.json")
+	if err := os.Mkdir(outDir, 0o700); err != nil {
+		t.Fatalf("Mkdir: %v", err)
+	}
+
+	if err := WriteBOM(minimalBOM(), outDir, "json", ""); err == nil {
+		t.Fatalf("expected error when output path is a directory")
+	}
+}
+
+func TestWriteBOM_UnsupportedFormat_Errors(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "bom.json")
+
+	if err := WriteBOM(minimalBOM(), out, "yaml", ""); err == nil {
+		t.Fatalf("expected error for unsupported write format")
+	}
+}
+
+func TestWriteBOM_ExtensionMismatch_XMLFormatButJSONPath(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "bom.json")
+
+	if err := WriteBOM(minimalBOM(), out, "xml", ""); err == nil {
+		t.Fatalf("expected error for extension/format mismatch")
+	}
+}
+
+func TestWriteBOM_ExtensionMismatch_JSONFormatButXMLPath(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "bom.xml")
+
+	if err := WriteBOM(minimalBOM(), out, "json", ""); err == nil {
+		t.Fatalf("expected error for extension/format mismatch")
+	}
+}
+
+func TestWriteBOM_SpecProvidedButInvalid_ReturnsError(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "bom.json")
+
+	if err := WriteBOM(minimalBOM(), out, "json", "9.9"); err == nil {
+		t.Fatalf("expected error for unsupported CycloneDX spec version")
+	}
+}
+
+func TestWriteBOM_Auto_UppercaseXMLExtension_HitsEqualFoldThenValidationMismatch(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "bom.XML") // ext is ".XML"
+
+	// auto picks "xml" due to EqualFold(ext, ".xml"), then validation compares ext != ".xml" and errors.
+	if err := WriteBOM(minimalBOM(), out, "auto", ""); err == nil {
+		t.Fatalf("expected error for uppercase .XML extension validation mismatch")
+	}
+}
