chore: modernize workflows, security scanning, and linting configuration (#50)

* build: update Go 1.25, CI workflows, and build tooling

- Upgrade to Go 1.25
- Add benchmark targets to Makefile
- Implement parallel gosec execution
- Lock tool versions for reproducibility
- Add shellcheck directives to scripts
- Update CI workflows with improved caching

* refactor: migrate from golangci-lint to revive

- Replace golangci-lint with revive for linting
- Configure comprehensive revive rules
- Fix all EditorConfig violations
- Add yamllint and yamlfmt support
- Remove deprecated .golangci.yml

* refactor: rename utils to shared and deduplicate code

- Rename utils package to shared
- Add shared constants package
- Deduplicate constants across packages
- Address CodeRabbit review feedback

* fix: resolve SonarQube issues and add safety guards

- Fix all 73 SonarQube OPEN issues
- Add nil guards for resourceMonitor, backpressure, metricsCollector
- Implement io.Closer for headerFileReader
- Propagate errors from processing helpers
- Add metrics and templates packages
- Improve error handling across codebase

* test: improve test infrastructure and coverage

- Add benchmarks for cli, fileproc, metrics
- Improve test coverage for cli, fileproc, config
- Refactor tests with helper functions
- Add shared test constants
- Fix test function naming conventions
- Reduce cognitive complexity in benchmark tests

* docs: update documentation and configuration examples

- Update CLAUDE.md with current project state
- Refresh README with new features
- Add usage and configuration examples
- Add SonarQube project configuration
- Consolidate config.example.yaml

* fix: resolve shellcheck warnings in scripts

- Use ./*.go instead of *.go to prevent dash-prefixed filenames
  from being interpreted as options (SC2035)
- Remove unreachable return statement after exit (SC2317)
- Remove obsolete gibidiutils/ directory reference

* chore(deps): upgrade go dependencies

* chore(lint): megalinter fixes

* fix: improve test coverage and fix file descriptor leaks

- Add defer r.Close() to fix pipe file descriptor leaks in benchmark tests
- Refactor TestProcessorConfigureFileTypes with helper functions and assertions
- Refactor TestProcessorLogFinalStats with output capture and keyword verification
- Use shared constants instead of literal strings (TestFilePNG, FormatMarkdown, etc.)
- Reduce cognitive complexity by extracting helper functions

* fix: align test comments with function names

Remove underscores from test comments to match actual function names:
- benchmark/benchmark_test.go (2 fixes)
- fileproc/filetypes_config_test.go (4 fixes)
- fileproc/filetypes_registry_test.go (6 fixes)
- fileproc/processor_test.go (6 fixes)
- fileproc/resource_monitor_types_test.go (4 fixes)
- fileproc/writer_test.go (3 fixes)

* fix: various test improvements and bug fixes

- Remove duplicate maxCacheSize check in filetypes_registry_test.go
- Shorten long comment in processor_test.go to stay under 120 chars
- Remove flaky time.Sleep in collector_test.go, use >= 0 assertion
- Close pipe reader in benchmark_test.go to fix file descriptor leak
- Use ContinueOnError in flags_test.go to match ResetFlags behavior
- Add nil check for p.ui in processor_workers.go before UpdateProgress
- Fix resource_monitor_validation_test.go by setting hardMemoryLimitBytes directly

* chore(yaml): add missing document start markers

Add --- document start to YAML files to satisfy yamllint:
- .github/workflows/codeql.yml
- .github/workflows/build-test-publish.yml
- .github/workflows/security.yml
- .github/actions/setup/action.yml

* fix: guard nil resourceMonitor and fix test deadlock

- Guard resourceMonitor before CreateFileProcessingContext call
- Add ui.UpdateProgress on emergency stop and path error returns
- Fix potential deadlock in TestProcessFile using wg.Go with defer close
This commit is contained in:
2025-12-10 19:07:11 +02:00
committed by GitHub
parent ea4a39a360
commit 95b7ef6dd3
149 changed files with 22990 additions and 8976 deletions

264
main_run_test.go Normal file
View File

@@ -0,0 +1,264 @@
package main
import (
"context"
"flag"
"os"
"testing"
"github.com/ivuorinen/gibidify/cli"
"github.com/ivuorinen/gibidify/shared"
"github.com/ivuorinen/gibidify/testutil"
)
// TestRunErrorPaths tests various error paths in the run() function.
func TestRunErrorPaths(t *testing.T) {
tests := []struct {
name string
setup func(t *testing.T)
expectError bool
errorSubstr string
}{
{
name: "Invalid flags - missing source",
setup: func(_ *testing.T) {
// Reset flags and set invalid args
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
// Set args with missing source
os.Args = []string{
"gibidify", shared.TestCLIFlagDestination, shared.TestOutputMD, shared.TestCLIFlagNoUI,
}
},
expectError: true,
errorSubstr: "parsing flags",
},
{
name: "Invalid flags - invalid format",
setup: func(t *testing.T) {
// Reset flags and set invalid args
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
srcDir := t.TempDir()
outFile, outPath := testutil.CreateTempOutputFile(t, shared.TestOutputMD)
testutil.CloseFile(t, outFile)
// Set args with invalid format
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, srcDir, shared.TestCLIFlagDestination, outPath,
shared.TestCLIFlagFormat, "invalid", shared.TestCLIFlagNoUI,
}
},
expectError: true,
errorSubstr: shared.TestOpParsingFlags,
},
{
name: "Invalid source directory",
setup: func(t *testing.T) {
// Reset flags and set args with non-existent source
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
outFile, outPath := testutil.CreateTempOutputFile(t, shared.TestOutputMD)
testutil.CloseFile(t, outFile)
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, "/nonexistent/directory",
shared.TestCLIFlagDestination, outPath, shared.TestCLIFlagNoUI,
}
},
expectError: true,
errorSubstr: shared.TestOpParsingFlags, // Flag validation catches this, not processing
},
{
name: "Valid run with minimal setup",
setup: func(t *testing.T) {
// Reset flags
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
// Create valid setup
srcDir := testutil.SetupTempDirWithStructure(t, []testutil.DirSpec{
{
Path: "",
Files: []testutil.FileSpec{
{Name: shared.TestFileTXT, Content: shared.TestContent},
},
},
})
outFile, outPath := testutil.CreateTempOutputFile(t, shared.TestOutputMD)
testutil.CloseFile(t, outFile)
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, srcDir,
shared.TestCLIFlagDestination, outPath, shared.TestCLIFlagNoUI,
}
},
expectError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Suppress all output for cleaner test output
restore := testutil.SuppressAllOutput(t)
defer restore()
// Setup test case
tt.setup(t)
// Run the function
ctx := context.Background()
err := run(ctx)
// Check expectations
if tt.expectError {
testutil.AssertExpectedError(t, err, "run() with error case")
if tt.errorSubstr != "" {
testutil.AssertErrorContains(t, err, tt.errorSubstr, "run() error content")
}
} else {
testutil.AssertNoError(t, err, "run() success case")
}
})
}
}
// TestRunFlagParsing tests the flag parsing path in run() function.
func TestRunFlagParsing(t *testing.T) {
// Suppress logs for cleaner test output
restoreLogs := testutil.SuppressLogs(t)
defer restoreLogs()
// Save original args
oldArgs := os.Args
defer func() { os.Args = oldArgs }()
// Test with empty args (should use defaults)
t.Run("default args", func(t *testing.T) {
// Reset flags
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
// Create minimal valid setup
srcDir := testutil.SetupTempDirWithStructure(t, []testutil.DirSpec{
{
Path: "",
Files: []testutil.FileSpec{
{Name: shared.TestFileTXT, Content: shared.TestContent},
},
},
})
outFile, outPath := testutil.CreateTempOutputFile(t, "test_output.json")
testutil.CloseFile(t, outFile)
// Set minimal required args
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, srcDir,
shared.TestCLIFlagDestination, outPath, shared.TestCLIFlagNoUI,
}
// Run and verify it works with defaults
ctx := context.Background()
err := run(ctx)
testutil.AssertNoError(t, err, "run() with default flags")
})
}
// TestRunWithCanceledContext tests run() with pre-canceled context.
func TestRunWithCanceledContext(t *testing.T) {
// Suppress logs for cleaner test output
restoreLogs := testutil.SuppressLogs(t)
defer restoreLogs()
// Save original args
oldArgs := os.Args
defer func() { os.Args = oldArgs }()
// Reset flags
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
// Create valid setup
srcDir := testutil.SetupTempDirWithStructure(t, []testutil.DirSpec{
{
Path: "",
Files: []testutil.FileSpec{
{Name: shared.TestFileGo, Content: shared.LiteralPackageMain + "\nfunc main() {}"},
},
},
})
outFile, outPath := testutil.CreateTempOutputFile(t, shared.TestOutputMD)
testutil.CloseFile(t, outFile)
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, srcDir,
shared.TestCLIFlagDestination, outPath, shared.TestCLIFlagNoUI,
}
// Create canceled context
ctx, cancel := context.WithCancel(context.Background())
cancel() // Cancel immediately
// Run with canceled context
err := run(ctx)
// Should get processing error due to canceled context
testutil.AssertExpectedError(t, err, "run() with canceled context")
testutil.AssertErrorContains(t, err, "processing", "run() canceled context error")
}
// TestRunLogLevel tests the log level setting in run().
func TestRunLogLevel(t *testing.T) {
// Suppress logs for cleaner test output
restoreLogs := testutil.SuppressLogs(t)
defer restoreLogs()
// Save original args
oldArgs := os.Args
defer func() { os.Args = oldArgs }()
tests := []struct {
name string
logLevel string
}{
{"debug level", "debug"},
{"info level", "info"},
{"warn level", "warn"},
{"error level", "error"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Reset flags
cli.ResetFlags()
flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
// Create valid setup
srcDir := testutil.SetupTempDirWithStructure(t, []testutil.DirSpec{
{
Path: "",
Files: []testutil.FileSpec{
{Name: shared.TestFileTXT, Content: shared.TestContent},
},
},
})
outFile, outPath := testutil.CreateTempOutputFile(t, shared.TestOutputMD)
testutil.CloseFile(t, outFile)
// Set args with log level
os.Args = []string{
"gibidify", shared.TestCLIFlagSource, srcDir, shared.TestCLIFlagDestination, outPath,
"-log-level", tt.logLevel, shared.TestCLIFlagNoUI,
}
// Run
ctx := context.Background()
err := run(ctx)
// Should succeed
testutil.AssertNoError(t, err, "run() with log level "+tt.logLevel)
})
}
}