feat: update go to 1.25, add permissions and envs (#49)

* chore(ci): update go to 1.25, add permissions and envs
* fix(ci): update pr-lint.yml
* chore: update go, fix linting
* fix: tests and linting
* fix(lint): lint fixes, renovate should now pass
* fix: updates, security upgrades
* chore: workflow updates, lint
* fix: more lint, checkmake, and other fixes
* fix: more lint, convert scripts to POSIX compliant
* fix: simplify codeql workflow
* tests: increase test coverage, fix found issues
* fix(lint): editorconfig checking, add to linters
* fix(lint): shellcheck, add to linters
* fix(lint): apply cr comment suggestions
* fix(ci): remove step-security/harden-runner
* fix(lint): remove duplication, apply cr fixes
* fix(ci): tests in CI/CD pipeline
* chore(lint): deduplication of strings
* fix(lint): apply cr comment suggestions
* fix(ci): actionlint
* fix(lint): apply cr comment suggestions
* chore: lint, add deps management

fileproc/backpressure_behavior_test.go

@@ -0,0 +1,177 @@
+package fileproc
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBackpressureManagerShouldApplyBackpressure(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("returns false when disabled", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = false
+
+		shouldApply := bm.ShouldApplyBackpressure(ctx)
+		assert.False(t, shouldApply)
+	})
+
+	t.Run("checks memory at intervals", func(_ *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+		bm.memoryCheckInterval = 10
+
+		// Should not check memory on most calls
+		for i := 1; i < 10; i++ {
+			shouldApply := bm.ShouldApplyBackpressure(ctx)
+			// Can't predict result, but shouldn't panic
+			_ = shouldApply
+		}
+
+		// Should check memory on 10th call
+		shouldApply := bm.ShouldApplyBackpressure(ctx)
+		// Result depends on actual memory usage
+		_ = shouldApply
+	})
+
+	t.Run("detects high memory usage", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+		bm.memoryCheckInterval = 1
+		bm.maxMemoryUsage = 1 // Set very low limit to trigger
+
+		shouldApply := bm.ShouldApplyBackpressure(ctx)
+		// Should detect high memory usage
+		assert.True(t, shouldApply)
+	})
+}
+
+func TestBackpressureManagerApplyBackpressure(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("does nothing when disabled", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = false
+
+		// Use a channel to verify the function returns quickly
+		done := make(chan struct{})
+		go func() {
+			bm.ApplyBackpressure(ctx)
+			close(done)
+		}()
+
+		// Should complete quickly when disabled
+		select {
+		case <-done:
+			// Success - function returned
+		case <-time.After(50 * time.Millisecond):
+			t.Fatal("ApplyBackpressure did not return quickly when disabled")
+		}
+	})
+
+	t.Run("applies delay when enabled", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+
+		// Use a channel to verify the function blocks for some time
+		done := make(chan struct{})
+		started := make(chan struct{})
+		go func() {
+			close(started)
+			bm.ApplyBackpressure(ctx)
+			close(done)
+		}()
+
+		// Wait for goroutine to start
+		<-started
+
+		// Should NOT complete immediately - verify it blocks for at least 5ms
+		select {
+		case <-done:
+			t.Fatal("ApplyBackpressure returned too quickly when enabled")
+		case <-time.After(5 * time.Millisecond):
+			// Good - it's blocking as expected
+		}
+
+		// Now wait for it to complete (should finish within reasonable time)
+		select {
+		case <-done:
+			// Success - function eventually returned
+		case <-time.After(500 * time.Millisecond):
+			t.Fatal("ApplyBackpressure did not complete within timeout")
+		}
+	})
+
+	t.Run("respects context cancellation", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel() // Cancel immediately
+
+		start := time.Now()
+		bm.ApplyBackpressure(ctx)
+		duration := time.Since(start)
+
+		// Should return quickly when context is cancelled
+		assert.Less(t, duration, 5*time.Millisecond)
+	})
+}
+
+func TestBackpressureManagerLogBackpressureInfo(t *testing.T) {
+	bm := NewBackpressureManager()
+	bm.enabled = true // Ensure enabled so filesProcessed is incremented
+
+	// Apply some operations
+	ctx := context.Background()
+	bm.ShouldApplyBackpressure(ctx)
+	bm.ApplyBackpressure(ctx)
+
+	// This should not panic
+	bm.LogBackpressureInfo()
+
+	stats := bm.GetStats()
+	assert.Greater(t, stats.FilesProcessed, int64(0))
+}
+
+func TestBackpressureManagerMemoryLimiting(t *testing.T) {
+	t.Run("triggers on low memory limit", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+		bm.memoryCheckInterval = 1 // Check every file
+		bm.maxMemoryUsage = 1      // Very low limit to guarantee trigger
+
+		ctx := context.Background()
+
+		// Should detect memory over limit
+		shouldApply := bm.ShouldApplyBackpressure(ctx)
+		assert.True(t, shouldApply)
+		stats := bm.GetStats()
+		assert.True(t, stats.MemoryWarningActive)
+	})
+
+	t.Run("resets warning when memory normalizes", func(t *testing.T) {
+		bm := NewBackpressureManager()
+		bm.enabled = true
+		bm.memoryCheckInterval = 1
+		// Simulate warning by first triggering high memory usage
+		bm.maxMemoryUsage = 1 // Very low to trigger warning
+		ctx := context.Background()
+		_ = bm.ShouldApplyBackpressure(ctx)
+		stats := bm.GetStats()
+		assert.True(t, stats.MemoryWarningActive)
+
+		// Now set high limit so we're under it
+		bm.maxMemoryUsage = 1024 * 1024 * 1024 * 10 // 10GB
+
+		shouldApply := bm.ShouldApplyBackpressure(ctx)
+		assert.False(t, shouldApply)
+
+		// Warning should be reset (via public API)
+		stats = bm.GetStats()
+		assert.False(t, stats.MemoryWarningActive)
+	})
+}