chore: add lint workflow and extensive unit tests for jobs, metrics and builtins

Author: Alpine

.github/workflows/lint.yml

@@ -0,0 +1,26 @@
+name: Lint
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.60
+          args: --timeout=5m

internal/jobs/jobs_test.go

@@ -0,0 +1,117 @@
+package jobs
+
+import (
+	"testing"
+	"time"
+)
+
+func TestJobStoreCreateAndGet(t *testing.T) {
+	store := NewStore()
+	job, err := store.Create()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if job.Status != StatusPending {
+		t.Fatalf("expected pending, got %s", job.Status)
+	}
+
+	fetched, ok := store.Get(job.ID)
+	if !ok || fetched.ID != job.ID {
+		t.Fatal("failed to get job")
+	}
+}
+
+func TestJobStoreUpdateProgress(t *testing.T) {
+	store := NewStore()
+	job, _ := store.Create()
+
+	store.UpdateProgress(job.ID, 50)
+	fetched, _ := store.Get(job.ID)
+	if fetched.Progress != 50 || fetched.Status != StatusSlicing {
+		t.Fatalf("expected progress 50 and status slicing, got %d %s", fetched.Progress, fetched.Status)
+	}
+
+	// Should cap at 99
+	store.UpdateProgress(job.ID, 150)
+	fetched, _ = store.Get(job.ID)
+	if fetched.Progress != 99 {
+		t.Fatalf("expected progress capped at 99, got %d", fetched.Progress)
+	}
+}
+
+func TestJobStoreUpdateStatus(t *testing.T) {
+	store := NewStore()
+	job, _ := store.Create()
+
+	store.UpdateStatus(job.ID, StatusCompleted, nil)
+	fetched, _ := store.Get(job.ID)
+	if fetched.Status != StatusCompleted || fetched.Progress != 100 {
+		t.Fatalf("expected completed and 100%%, got %s %d", fetched.Status, fetched.Progress)
+	}
+}
+
+func TestJobStoreCancel(t *testing.T) {
+	store := NewStore()
+	job, _ := store.Create()
+
+	cancelled := false
+	store.SetCancelFunc(job.ID, func() {
+		cancelled = true
+	})
+
+	if err := store.Cancel(job.ID); err != nil {
+		t.Fatal(err)
+	}
+	if !cancelled {
+		t.Fatal("cancel func not called")
+	}
+
+	fetched, _ := store.Get(job.ID)
+	if fetched.Status != StatusFailed {
+		t.Fatalf("expected failed status, got %s", fetched.Status)
+	}
+}
+
+func TestPersistentStore(t *testing.T) {
+	dir := t.TempDir()
+	store := NewPersistentStore(dir)
+
+	job, _ := store.Create()
+	store.UpdateStatus(job.ID, StatusSlicing, nil)
+
+	// Recreate store to simulate restart
+	store2 := NewPersistentStore(dir)
+	fetched, ok := store2.Get(job.ID)
+	if !ok {
+		t.Fatal("expected job to be recovered")
+	}
+	if fetched.Status != StatusFailed {
+		t.Fatalf("expected slicing job to become failed after restart, got %s", fetched.Status)
+	}
+
+	// Test completed job recovery
+	job2, _ := store.Create()
+	store.UpdateStatus(job2.ID, StatusCompleted, nil)
+	
+	store3 := NewPersistentStore(dir)
+	fetched2, _ := store3.Get(job2.ID)
+	if fetched2.Status != StatusCompleted {
+		t.Fatalf("expected completed job to remain completed, got %s", fetched2.Status)
+	}
+}
+
+func TestStoreCleanup(t *testing.T) {
+	store := NewStore()
+	job, _ := store.Create()
+	store.UpdateStatus(job.ID, StatusCompleted, nil)
+	
+	// Fast forward time for test
+	store.mu.Lock()
+	store.jobs[job.ID].UpdatedAt = time.Now().Add(-2 * time.Hour)
+	store.mu.Unlock()
+
+	store.Cleanup(1 * time.Hour)
+	if _, ok := store.Get(job.ID); ok {
+		t.Fatal("expected old completed job to be cleaned up")
+	}
+}

internal/metrics/handler_test.go

@@ -0,0 +1,49 @@
+package metrics
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/Brook-sys/orca-slicer-api/internal/jobs"
+	"github.com/Brook-sys/orca-slicer-api/internal/slicer"
+)
+
+func TestGetMetrics(t *testing.T) {
+	jobStore := jobs.NewStore()
+	jobStore.Create() // Creates a pending job
+
+	cache := slicer.NewResultCache(time.Hour, 10)
+	handler := Handler{
+		JobStore: jobStore,
+		Cache:    cache,
+		Startup:  time.Now().Add(-10 * time.Second),
+	}
+
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "/metrics", nil)
+	handler.GetMetrics(w, r)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var stats map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &stats); err != nil {
+		t.Fatal(err)
+	}
+
+	if stats["uptime_seconds"].(float64) < 9 {
+		t.Fatalf("expected uptime >= 9s")
+	}
+	if stats["cache_enabled"] != true {
+		t.Fatalf("expected cache_enabled=true")
+	}
+	
+	jobStats := stats["jobs"].(map[string]any)
+	if jobStats["total"].(float64) != 1 {
+		t.Fatalf("expected 1 total job, got %v", jobStats["total"])
+	}
+}

internal/slicer/builtins_test.go

@@ -0,0 +1,58 @@
+package slicer
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestListBuiltinProfiles(t *testing.T) {
+	dir := t.TempDir()
+	printersDir := filepath.Join(dir, "printers")
+	if err := os.MkdirAll(printersDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(printersDir, "A.json"), []byte("{}"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(printersDir, "B.json"), []byte("{}"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	service := &Service{OrcaProfilesPath: dir}
+	handler := Handler{Service: service}
+
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "/profiles/builtins/printers", nil)
+	r.SetPathValue("category", "printers")
+
+	handler.ListBuiltinProfiles(w, r)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var list []ProfileListItem
+	if err := json.Unmarshal(w.Body.Bytes(), &list); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(list) != 2 || list[0].Name != "A" || list[1].Name != "B" {
+		t.Fatalf("expected sorted list A, B, got %#v", list)
+	}
+}
+
+func TestListBuiltinProfilesInvalidCategory(t *testing.T) {
+	handler := Handler{}
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "/profiles/builtins/invalid", nil)
+	r.SetPathValue("category", "invalid")
+	handler.ListBuiltinProfiles(w, r)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for invalid category, got %d", w.Code)
+	}
+}