feat: add tests for validation, scanning and ui packages

Author: wiebe-vandendriessche

internal/completeness/completeness_test.go

@@ -1,12 +1,9 @@
 package completeness
 
 import (
-	"os"
-	"path/filepath"
 	"testing"
 
 	"github.com/idlab-discover/AIBoMGen-cli/internal/fetcher"
-	bomio "github.com/idlab-discover/AIBoMGen-cli/internal/io"
 	"github.com/idlab-discover/AIBoMGen-cli/internal/metadata"
 	"github.com/idlab-discover/AIBoMGen-cli/internal/scanner"
 
@@ -88,31 +85,6 @@ func buildFullyPopulatedBOMForRegistry(t *testing.T) *cdx.BOM {
 	return bom
 }
 
-func writeBOMFile(t *testing.T, path string, format cdx.BOMFileFormat) {
-	t.Helper()
-
-	bom := cdx.NewBOM()
-	bom.Metadata = &cdx.Metadata{
-		Component: &cdx.Component{
-			Type: cdx.ComponentTypeMachineLearningModel,
-			Name: "org/model",
-		},
-	}
-
-	f, err := os.Create(path)
-	if err != nil {
-		t.Fatalf("create file: %v", err)
-	}
-	t.Cleanup(func() { _ = f.Close() })
-
-	enc := cdx.NewBOMEncoder(f, format)
-	enc.SetPretty(true)
-
-	if err := enc.Encode(bom); err != nil {
-		t.Fatalf("encode bom: %v", err)
-	}
-}
-
 // Test Check function on empty BOM
 func TestCheck_EmptyBOM_MissingRequiredMatchesRegistry(t *testing.T) {
 	r := Check(&cdx.BOM{})
@@ -164,76 +136,3 @@ func TestCheck_FullyPopulatedBOM_ScoreIsOne(t *testing.T) {
 		t.Fatalf("Score = %v, want ~1.0", r.Score)
 	}
 }
-
-// Test ReadBOM function with various formats and error cases
-func TestReadBOM_JSON_ExplicitFormat(t *testing.T) {
-	dir := t.TempDir()
-	p := filepath.Join(dir, "bom.json")
-	writeBOMFile(t, p, cdx.BOMFileFormatJSON)
-
-	b, err := bomio.ReadBOM(p, "json")
-	if err != nil {
-		t.Fatalf("ReadBOM err = %v", err)
-	}
-	if b == nil || b.Metadata == nil || b.Metadata.Component == nil {
-		t.Fatalf("decoded bom missing metadata/component")
-	}
-}
-func TestReadBOM_XML_ExplicitFormat(t *testing.T) {
-	dir := t.TempDir()
-	p := filepath.Join(dir, "bom.xml")
-	writeBOMFile(t, p, cdx.BOMFileFormatXML)
-
-	b, err := bomio.ReadBOM(p, "xml")
-	if err != nil {
-		t.Fatalf("ReadBOM err = %v", err)
-	}
-	if b == nil || b.Metadata == nil || b.Metadata.Component == nil {
-		t.Fatalf("decoded bom missing metadata/component")
-	}
-}
-func TestReadBOM_AutoDetectsByExtension(t *testing.T) {
-	dir := t.TempDir()
-
-	pJSON := filepath.Join(dir, "bom.json")
-	writeBOMFile(t, pJSON, cdx.BOMFileFormatJSON)
-	if _, err := bomio.ReadBOM(pJSON, "auto"); err != nil {
-		t.Fatalf("ReadBOM(json, auto) err = %v", err)
-	}
-
-	pXML := filepath.Join(dir, "bom.xml")
-	writeBOMFile(t, pXML, cdx.BOMFileFormatXML)
-	if _, err := bomio.ReadBOM(pXML, ""); err != nil { // empty behaves like auto
-		t.Fatalf("ReadBOM(xml, empty) err = %v", err)
-	}
-}
-
-// Test ReadBOM function error cases
-func TestReadBOM_InvalidPath_ReturnsError(t *testing.T) {
-	if _, err := bomio.ReadBOM("/definitely/does/not/exist/lol.json", "json"); err == nil {
-		t.Fatalf("expected error for missing file")
-	}
-}
-
-// Test ReadBOM function error cases
-func TestReadBOM_InvalidContent_ReturnsDecodeError(t *testing.T) {
-	dir := t.TempDir()
-	p := filepath.Join(dir, "bad.json")
-	if err := os.WriteFile(p, []byte("{not valid json"), 0o644); err != nil {
-		t.Fatalf("write file: %v", err)
-	}
-
-	if _, err := bomio.ReadBOM(p, "json"); err == nil {
-		t.Fatalf("expected decode error")
-	}
-}
-
-func TestReadBOM_FormatMismatch_ReturnsDecodeError(t *testing.T) {
-	dir := t.TempDir()
-	p := filepath.Join(dir, "bom.json")
-	writeBOMFile(t, p, cdx.BOMFileFormatJSON)
-
-	if _, err := bomio.ReadBOM(p, "xml"); err == nil {
-		t.Fatalf("expected decode error when decoding json as xml")
-	}
-}

internal/scanner/scanner_test.go

@@ -1,34 +1,120 @@
 package scanner
 
 import (
+	"bytes"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
+
+	"github.com/idlab-discover/AIBoMGen-cli/internal/ui"
 )
 
-func TestScanDetectsModelAndWeight(t *testing.T) {
+func TestScanDetectsModelsDedupesAndLogs(t *testing.T) {
+	ui.Init(true)
 	dir := t.TempDir()
-
-	// Create a python file with a HF model reference
 	pyPath := filepath.Join(dir, "use_model.py")
-	pyContent := `from transformers import AutoModel\nAutoModel.from_pretrained("bert-base-uncased")`
+	pyContent := "from transformers import AutoModel\n" +
+		"AutoModel.from_pretrained(\"bert-base-uncased\")\n" +
+		"AutoModel.from_pretrained(\"bert-base-uncased\")\n"
 	if err := os.WriteFile(pyPath, []byte(pyContent), 0o644); err != nil {
-		t.Fatalf("failed to create python file: %v", err)
+		t.Fatalf("write python file: %v", err)
 	}
 
-	// Weight-file detection disabled; only verify model detection.
+	var buf bytes.Buffer
+	SetLogger(&buf)
+	t.Cleanup(func() { SetLogger(nil) })
+
+	comps, err := Scan(dir)
+	if err != nil {
+		t.Fatalf("Scan failed: %v", err)
+	}
+	if len(comps) != 1 {
+		t.Fatalf("expected 1 component, got %d", len(comps))
+	}
+	if !strings.Contains(comps[0].Evidence, "line 2") || !strings.Contains(comps[0].Evidence, "line 3") {
+		t.Fatalf("expected evidence to include both occurrences, got %q", comps[0].Evidence)
+	}
+
+	logs := buf.String()
+	if !strings.Contains(logs, "found model 'bert-base-uncased'") {
+		t.Fatalf("expected detection log, got %q", logs)
+	}
+	if !strings.Contains(logs, "detected 1 components (models: 1)") {
+		t.Fatalf("expected summary log, got %q", logs)
+	}
+}
+
+func TestScanSkipsUnreadableFiles(t *testing.T) {
+	dir := t.TempDir()
+	pyPath := filepath.Join(dir, "blocked.py")
+	if err := os.WriteFile(pyPath, []byte("AutoModel.from_pretrained(\"bert\")"), 0o644); err != nil {
+		t.Fatalf("write python file: %v", err)
+	}
+	if err := os.Chmod(pyPath, 0o000); err != nil {
+		t.Fatalf("chmod file: %v", err)
+	}
+	defer func() { _ = os.Chmod(pyPath, 0o644) }()
 
 	comps, err := Scan(dir)
 	if err != nil {
 		t.Fatalf("Scan failed: %v", err)
 	}
-	var foundModel bool
-	for _, c := range comps {
-		if c.Type == "model" && c.Name == "bert-base-uncased" {
-			foundModel = true
+	if len(comps) != 0 {
+		t.Fatalf("expected no components for unreadable files, got %d", len(comps))
+	}
+}
+
+func TestScanInvalidRootReturnsError(t *testing.T) {
+	missing := filepath.Join(t.TempDir(), "does-not-exist")
+	if _, err := Scan(missing); err == nil {
+		t.Fatalf("expected error for missing root")
+	}
+}
+
+func TestShouldScanForModelID(t *testing.T) {
+	tests := []struct {
+		ext  string
+		want bool
+	}{
+		{ext: ".py", want: true},
+		{ext: ".ipynb", want: true},
+		{ext: ".txt", want: true},
+		{ext: ".md", want: false},
+	}
+	for _, tt := range tests {
+		if got := shouldScanForModelID(tt.ext); got != tt.want {
+			t.Fatalf("shouldScanForModelID(%q) = %t, want %t", tt.ext, got, tt.want)
 		}
 	}
-	if !foundModel {
-		t.Errorf("expected model component for bert-base-uncased")
+}
+
+func TestDedupeMergesEvidence(t *testing.T) {
+	components := []Discovery{
+		{ID: "bert", Type: "model", Evidence: "line 2"},
+		{ID: "bert", Type: "model", Evidence: "line 3"},
+		{ID: "bert", Type: "model", Evidence: "line 3"},
+		{ID: "other", Type: "model", Evidence: "line 5"},
+	}
+
+	deduped := dedupe(components)
+	if len(deduped) != 2 {
+		t.Fatalf("expected 2 unique components, got %d", len(deduped))
+	}
+
+	var merged Discovery
+	for _, c := range deduped {
+		if c.ID == "bert" {
+			merged = c
+		}
+	}
+	if merged.ID == "" {
+		t.Fatalf("expected bert component after dedupe")
+	}
+	if !strings.Contains(merged.Evidence, "line 2") {
+		t.Fatalf("expected merged evidence to include line 2, got %q", merged.Evidence)
+	}
+	if strings.Count(merged.Evidence, "line 3") != 1 {
+		t.Fatalf("expected line 3 evidence once, got %q", merged.Evidence)
 	}
 }

internal/ui/ui_test.go

@@ -0,0 +1,36 @@
+package ui
+
+import "testing"
+
+func TestInitSetsEnabledFlag(t *testing.T) {
+	prev := Enabled
+	t.Cleanup(func() { Enabled = prev })
+
+	Enabled = true
+	Init(true)
+	if Enabled {
+		t.Fatalf("Init(true) should disable colors")
+	}
+
+	Init(false)
+	if !Enabled {
+		t.Fatalf("Init(false) should enable colors")
+	}
+}
+
+func TestColorRespectsEnabledFlag(t *testing.T) {
+	prev := Enabled
+	t.Cleanup(func() { Enabled = prev })
+
+	Enabled = true
+	got := Color("hello", FgGreen)
+	want := FgGreen + "hello" + Reset
+	if got != want {
+		t.Fatalf("Color enabled = %q, want %q", got, want)
+	}
+
+	Enabled = false
+	if got := Color("world", FgMagenta); got != "world" {
+		t.Fatalf("Color disabled = %q, want plain string", got)
+	}
+}

internal/validator/report_test.go

@@ -0,0 +1,82 @@
+package validator
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/idlab-discover/AIBoMGen-cli/internal/metadata"
+	"github.com/idlab-discover/AIBoMGen-cli/internal/ui"
+)
+
+func TestPrintReport_UsesConfiguredLoggerWriter(t *testing.T) {
+	ui.Init(true)
+
+	var buf bytes.Buffer
+	SetLogger(&buf)
+	t.Cleanup(func() { SetLogger(nil) })
+
+	PrintReport(ValidationResult{
+		Valid:             false,
+		Errors:            []string{"required field missing"},
+		Warnings:          []string{"optional field missing"},
+		CompletenessScore: 0.5,
+		MissingRequired:   []metadata.Key{metadata.ComponentName},
+		MissingOptional:   []metadata.Key{metadata.ComponentTags, metadata.ComponentLicenses},
+	})
+
+	got := buf.String()
+	want := "Validation Report: ❌ validation failed\n" +
+		"Validation Report: errors (1):\n" +
+		"Validation Report:   • required field missing\n" +
+		"Validation Report: warnings (1):\n" +
+		"Validation Report:   • optional field missing\n" +
+		"Validation Report: completeness score: 50.0% (1 required, 2 optional missing)\n"
+
+	if got != want {
+		t.Fatalf("output = %q, want %q", got, want)
+	}
+}
+
+func TestPrintReport_NoLoggerWriter_DoesNothing(t *testing.T) {
+	ui.Init(true)
+
+	SetLogger(nil)
+	PrintReport(ValidationResult{Valid: true})
+}
+
+func TestFormatSummary(t *testing.T) {
+	tests := []struct {
+		name string
+		res  ValidationResult
+		want string
+	}{
+		{
+			name: "passed",
+			res: ValidationResult{
+				Valid:             true,
+				CompletenessScore: 0.83,
+				Errors:            []string{"ignored"},
+				Warnings:          []string{"one", "two"},
+			},
+			want: "Validation: ✅ PASSED | Score: 83.0% | Errors: 1 | Warnings: 2",
+		},
+		{
+			name: "failed",
+			res: ValidationResult{
+				Valid:             false,
+				CompletenessScore: 0.42,
+				Errors:            []string{"a", "b"},
+				Warnings:          []string{"c"},
+			},
+			want: "Validation: ❌ FAILED | Score: 42.0% | Errors: 2 | Warnings: 1",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := FormatSummary(tt.res); got != tt.want {
+				t.Fatalf("FormatSummary() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}