2cad49de85
- Implement tests for BackupService to handle database extraction from backup archives with SHM and WAL entries. - Add tests for BackupService to validate behavior when creating backups for non-SQLite databases and handling oversized database entries. - Introduce tests for CrowdSec startup to ensure proper error handling during configuration creation. - Enhance LogService tests to cover scenarios for skipping dot and empty directories and handling read directory errors. - Add tests for SecurityHeadersService to ensure proper error handling during preset creation and updates. - Update ProxyHostForm tests to include HSTS subdomains toggle and validation for port input handling. - Enhance DNSProviders tests to validate manual challenge completion and error handling when no providers are available. - Extend UsersPage tests to ensure fallback mechanisms for clipboard operations when the clipboard API fails.
540 lines
15 KiB
Go
540 lines
15 KiB
Go
package patchreport
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestResolveThreshold(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
envValue string
|
|
envSet bool
|
|
defaultValue float64
|
|
wantValue float64
|
|
wantSource string
|
|
wantWarning bool
|
|
}{
|
|
{
|
|
name: "uses default when env is absent",
|
|
envSet: false,
|
|
defaultValue: 90,
|
|
wantValue: 90,
|
|
wantSource: "default",
|
|
wantWarning: false,
|
|
},
|
|
{
|
|
name: "uses env value when valid",
|
|
envSet: true,
|
|
envValue: "87.5",
|
|
defaultValue: 85,
|
|
wantValue: 87.5,
|
|
wantSource: "env",
|
|
wantWarning: false,
|
|
},
|
|
{
|
|
name: "falls back when env is invalid",
|
|
envSet: true,
|
|
envValue: "invalid",
|
|
defaultValue: 85,
|
|
wantValue: 85,
|
|
wantSource: "default",
|
|
wantWarning: true,
|
|
},
|
|
{
|
|
name: "falls back when env is out of range",
|
|
envSet: true,
|
|
envValue: "101",
|
|
defaultValue: 85,
|
|
wantValue: 85,
|
|
wantSource: "default",
|
|
wantWarning: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
lookup := func(name string) (string, bool) {
|
|
if name != "TARGET" {
|
|
t.Fatalf("unexpected env lookup key: %s", name)
|
|
}
|
|
if !tt.envSet {
|
|
return "", false
|
|
}
|
|
return tt.envValue, true
|
|
}
|
|
|
|
resolved := ResolveThreshold("TARGET", tt.defaultValue, lookup)
|
|
if resolved.Value != tt.wantValue {
|
|
t.Fatalf("value mismatch: got %.1f want %.1f", resolved.Value, tt.wantValue)
|
|
}
|
|
if resolved.Source != tt.wantSource {
|
|
t.Fatalf("source mismatch: got %s want %s", resolved.Source, tt.wantSource)
|
|
}
|
|
hasWarning := resolved.Warning != ""
|
|
if hasWarning != tt.wantWarning {
|
|
t.Fatalf("warning mismatch: got %v want %v (warning=%q)", hasWarning, tt.wantWarning, resolved.Warning)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResolveThreshold_WithNilLookupUsesOSLookupEnv(t *testing.T) {
|
|
t.Setenv("PATCH_THRESHOLD_TEST", "91.2")
|
|
|
|
resolved := ResolveThreshold("PATCH_THRESHOLD_TEST", 85.0, nil)
|
|
if resolved.Value != 91.2 {
|
|
t.Fatalf("expected env value 91.2, got %.1f", resolved.Value)
|
|
}
|
|
if resolved.Source != "env" {
|
|
t.Fatalf("expected source env, got %s", resolved.Source)
|
|
}
|
|
}
|
|
|
|
func TestParseUnifiedDiffChangedLines(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
diff := `diff --git a/backend/internal/app.go b/backend/internal/app.go
|
|
index 1111111..2222222 100644
|
|
--- a/backend/internal/app.go
|
|
+++ b/backend/internal/app.go
|
|
@@ -10,2 +10,3 @@ func example() {
|
|
line10
|
|
-line11
|
|
+line11 changed
|
|
+line12 new
|
|
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
|
|
index 3333333..4444444 100644
|
|
--- a/frontend/src/App.tsx
|
|
+++ b/frontend/src/App.tsx
|
|
@@ -20,0 +21,2 @@ export default function App() {
|
|
+new frontend line
|
|
+another frontend line
|
|
`
|
|
|
|
backendChanged, frontendChanged, err := ParseUnifiedDiffChangedLines(diff)
|
|
if err != nil {
|
|
t.Fatalf("ParseUnifiedDiffChangedLines returned error: %v", err)
|
|
}
|
|
|
|
assertHasLines(t, backendChanged, "backend/internal/app.go", []int{11, 12})
|
|
assertHasLines(t, frontendChanged, "frontend/src/App.tsx", []int{21, 22})
|
|
}
|
|
|
|
func TestParseUnifiedDiffChangedLines_InvalidHunkStartReturnsError(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
diff := `diff --git a/backend/internal/app.go b/backend/internal/app.go
|
|
index 1111111..2222222 100644
|
|
--- a/backend/internal/app.go
|
|
+++ b/backend/internal/app.go
|
|
@@ -1,1 +abc,2 @@
|
|
+line
|
|
`
|
|
|
|
backendChanged, frontendChanged, err := ParseUnifiedDiffChangedLines(diff)
|
|
if err != nil {
|
|
t.Fatalf("expected graceful handling for invalid hunk, got error: %v", err)
|
|
}
|
|
if len(backendChanged) != 0 || len(frontendChanged) != 0 {
|
|
t.Fatalf("expected no changed lines for invalid hunk, got backend=%v frontend=%v", backendChanged, frontendChanged)
|
|
}
|
|
}
|
|
|
|
func TestBackendChangedLineCoverageComputation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tempDir := t.TempDir()
|
|
coverageFile := filepath.Join(tempDir, "coverage.txt")
|
|
coverageContent := `mode: atomic
|
|
github.com/Wikid82/charon/backend/internal/service.go:10.1,10.20 1 1
|
|
github.com/Wikid82/charon/backend/internal/service.go:11.1,11.20 1 0
|
|
github.com/Wikid82/charon/backend/internal/service.go:12.1,12.20 1 1
|
|
`
|
|
if err := os.WriteFile(coverageFile, []byte(coverageContent), 0o600); err != nil {
|
|
t.Fatalf("failed to write temp coverage file: %v", err)
|
|
}
|
|
|
|
coverage, err := ParseGoCoverageProfile(coverageFile)
|
|
if err != nil {
|
|
t.Fatalf("ParseGoCoverageProfile returned error: %v", err)
|
|
}
|
|
|
|
changed := FileLineSet{
|
|
"backend/internal/service.go": {10: {}, 11: {}, 15: {}},
|
|
}
|
|
|
|
scope := ComputeScopeCoverage(changed, coverage)
|
|
if scope.ChangedLines != 2 {
|
|
t.Fatalf("changed lines mismatch: got %d want 2", scope.ChangedLines)
|
|
}
|
|
if scope.CoveredLines != 1 {
|
|
t.Fatalf("covered lines mismatch: got %d want 1", scope.CoveredLines)
|
|
}
|
|
if scope.PatchCoveragePct != 50.0 {
|
|
t.Fatalf("coverage pct mismatch: got %.1f want 50.0", scope.PatchCoveragePct)
|
|
}
|
|
}
|
|
|
|
func TestFrontendChangedLineCoverageComputationFromLCOV(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tempDir := t.TempDir()
|
|
lcovFile := filepath.Join(tempDir, "lcov.info")
|
|
lcovContent := `TN:
|
|
SF:frontend/src/App.tsx
|
|
DA:10,1
|
|
DA:11,0
|
|
DA:12,1
|
|
end_of_record
|
|
`
|
|
if err := os.WriteFile(lcovFile, []byte(lcovContent), 0o600); err != nil {
|
|
t.Fatalf("failed to write temp lcov file: %v", err)
|
|
}
|
|
|
|
coverage, err := ParseLCOVProfile(lcovFile)
|
|
if err != nil {
|
|
t.Fatalf("ParseLCOVProfile returned error: %v", err)
|
|
}
|
|
|
|
changed := FileLineSet{
|
|
"frontend/src/App.tsx": {10: {}, 11: {}, 13: {}},
|
|
}
|
|
|
|
scope := ComputeScopeCoverage(changed, coverage)
|
|
if scope.ChangedLines != 2 {
|
|
t.Fatalf("changed lines mismatch: got %d want 2", scope.ChangedLines)
|
|
}
|
|
if scope.CoveredLines != 1 {
|
|
t.Fatalf("covered lines mismatch: got %d want 1", scope.CoveredLines)
|
|
}
|
|
if scope.PatchCoveragePct != 50.0 {
|
|
t.Fatalf("coverage pct mismatch: got %.1f want 50.0", scope.PatchCoveragePct)
|
|
}
|
|
|
|
status := ApplyStatus(scope, 85)
|
|
if status.Status != "warn" {
|
|
t.Fatalf("status mismatch: got %s want warn", status.Status)
|
|
}
|
|
}
|
|
|
|
func TestParseUnifiedDiffChangedLines_AllowsLongLines(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
longLine := strings.Repeat("x", 128*1024)
|
|
diff := strings.Join([]string{
|
|
"diff --git a/backend/internal/app.go b/backend/internal/app.go",
|
|
"index 1111111..2222222 100644",
|
|
"--- a/backend/internal/app.go",
|
|
"+++ b/backend/internal/app.go",
|
|
"@@ -1,1 +1,2 @@",
|
|
" line1",
|
|
"+" + longLine,
|
|
}, "\n")
|
|
|
|
backendChanged, _, err := ParseUnifiedDiffChangedLines(diff)
|
|
if err != nil {
|
|
t.Fatalf("ParseUnifiedDiffChangedLines returned error for long line: %v", err)
|
|
}
|
|
|
|
assertHasLines(t, backendChanged, "backend/internal/app.go", []int{2})
|
|
}
|
|
|
|
func TestParseGoCoverageProfile_AllowsLongLines(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tempDir := t.TempDir()
|
|
coverageFile := filepath.Join(tempDir, "coverage.txt")
|
|
longSegment := strings.Repeat("a", 128*1024)
|
|
coverageContent := "mode: atomic\n" +
|
|
"github.com/Wikid82/charon/backend/internal/" + longSegment + ".go:10.1,10.20 1 1\n"
|
|
if err := os.WriteFile(coverageFile, []byte(coverageContent), 0o600); err != nil {
|
|
t.Fatalf("failed to write temp coverage file: %v", err)
|
|
}
|
|
|
|
_, err := ParseGoCoverageProfile(coverageFile)
|
|
if err != nil {
|
|
t.Fatalf("ParseGoCoverageProfile returned error for long line: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestParseLCOVProfile_AllowsLongLines(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tempDir := t.TempDir()
|
|
lcovFile := filepath.Join(tempDir, "lcov.info")
|
|
longPath := strings.Repeat("a", 128*1024)
|
|
lcovContent := strings.Join([]string{
|
|
"TN:",
|
|
"SF:frontend/src/" + longPath + ".tsx",
|
|
"DA:10,1",
|
|
"end_of_record",
|
|
}, "\n")
|
|
if err := os.WriteFile(lcovFile, []byte(lcovContent), 0o600); err != nil {
|
|
t.Fatalf("failed to write temp lcov file: %v", err)
|
|
}
|
|
|
|
_, err := ParseLCOVProfile(lcovFile)
|
|
if err != nil {
|
|
t.Fatalf("ParseLCOVProfile returned error for long line: %v", err)
|
|
}
|
|
}
|
|
|
|
func assertHasLines(t *testing.T, changed FileLineSet, file string, expected []int) {
|
|
t.Helper()
|
|
|
|
lines, ok := changed[file]
|
|
if !ok {
|
|
t.Fatalf("file %s not found in changed lines", file)
|
|
}
|
|
for _, line := range expected {
|
|
if _, hasLine := lines[line]; !hasLine {
|
|
t.Fatalf("expected line %d in file %s", line, file)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestValidateReadablePath(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("returns error for empty path", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
_, err := validateReadablePath(" ")
|
|
if err == nil {
|
|
t.Fatal("expected error for empty path")
|
|
}
|
|
})
|
|
|
|
t.Run("returns absolute cleaned path", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
path, err := validateReadablePath("./backend/../backend/internal")
|
|
if err != nil {
|
|
t.Fatalf("expected no error, got %v", err)
|
|
}
|
|
if !filepath.IsAbs(path) {
|
|
t.Fatalf("expected absolute path, got %q", path)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestComputeFilesNeedingCoverage_IncludesUncoveredAndSortsDeterministically(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
changed := FileLineSet{
|
|
"backend/internal/b.go": {1: {}, 2: {}},
|
|
"backend/internal/a.go": {1: {}, 2: {}},
|
|
"backend/internal/c.go": {1: {}, 2: {}},
|
|
}
|
|
|
|
coverage := CoverageData{
|
|
Executable: FileLineSet{
|
|
"backend/internal/a.go": {1: {}, 2: {}},
|
|
"backend/internal/b.go": {1: {}, 2: {}},
|
|
"backend/internal/c.go": {1: {}, 2: {}},
|
|
},
|
|
Covered: FileLineSet{
|
|
"backend/internal/a.go": {1: {}},
|
|
"backend/internal/c.go": {1: {}, 2: {}},
|
|
},
|
|
}
|
|
|
|
details := ComputeFilesNeedingCoverage(changed, coverage, 40)
|
|
if len(details) != 2 {
|
|
t.Fatalf("expected 2 files needing coverage, got %d", len(details))
|
|
}
|
|
|
|
if details[0].Path != "backend/internal/b.go" {
|
|
t.Fatalf("expected first file to be backend/internal/b.go, got %s", details[0].Path)
|
|
}
|
|
if details[0].PatchCoveragePct != 0.0 {
|
|
t.Fatalf("expected first file coverage 0.0, got %.1f", details[0].PatchCoveragePct)
|
|
}
|
|
if details[0].UncoveredChangedLines != 2 {
|
|
t.Fatalf("expected first file uncovered lines 2, got %d", details[0].UncoveredChangedLines)
|
|
}
|
|
if strings.Join(details[0].UncoveredChangedLineRange, ",") != "1-2" {
|
|
t.Fatalf("expected first file uncovered ranges 1-2, got %v", details[0].UncoveredChangedLineRange)
|
|
}
|
|
|
|
if details[1].Path != "backend/internal/a.go" {
|
|
t.Fatalf("expected second file to be backend/internal/a.go, got %s", details[1].Path)
|
|
}
|
|
if details[1].PatchCoveragePct != 50.0 {
|
|
t.Fatalf("expected second file coverage 50.0, got %.1f", details[1].PatchCoveragePct)
|
|
}
|
|
if details[1].UncoveredChangedLines != 1 {
|
|
t.Fatalf("expected second file uncovered lines 1, got %d", details[1].UncoveredChangedLines)
|
|
}
|
|
if strings.Join(details[1].UncoveredChangedLineRange, ",") != "2" {
|
|
t.Fatalf("expected second file uncovered range 2, got %v", details[1].UncoveredChangedLineRange)
|
|
}
|
|
}
|
|
|
|
func TestComputeFilesNeedingCoverage_IncludesFullyCoveredWhenThresholdAbove100(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
changed := FileLineSet{
|
|
"backend/internal/fully.go": {10: {}, 11: {}},
|
|
}
|
|
coverage := CoverageData{
|
|
Executable: FileLineSet{
|
|
"backend/internal/fully.go": {10: {}, 11: {}},
|
|
},
|
|
Covered: FileLineSet{
|
|
"backend/internal/fully.go": {10: {}, 11: {}},
|
|
},
|
|
}
|
|
|
|
details := ComputeFilesNeedingCoverage(changed, coverage, 101)
|
|
if len(details) != 1 {
|
|
t.Fatalf("expected 1 file detail when threshold is 101, got %d", len(details))
|
|
}
|
|
if details[0].PatchCoveragePct != 100.0 {
|
|
t.Fatalf("expected 100%% patch coverage detail, got %.1f", details[0].PatchCoveragePct)
|
|
}
|
|
}
|
|
|
|
func TestMergeFileCoverageDetails_SortsWorstCoverageThenPath(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
merged := MergeFileCoverageDetails(
|
|
[]FileCoverageDetail{
|
|
{Path: "frontend/src/z.ts", PatchCoveragePct: 50.0},
|
|
{Path: "frontend/src/a.ts", PatchCoveragePct: 50.0},
|
|
},
|
|
[]FileCoverageDetail{
|
|
{Path: "backend/internal/w.go", PatchCoveragePct: 0.0},
|
|
},
|
|
)
|
|
|
|
if len(merged) != 3 {
|
|
t.Fatalf("expected 3 merged items, got %d", len(merged))
|
|
}
|
|
|
|
orderedPaths := []string{merged[0].Path, merged[1].Path, merged[2].Path}
|
|
got := strings.Join(orderedPaths, ",")
|
|
want := "backend/internal/w.go,frontend/src/a.ts,frontend/src/z.ts"
|
|
if got != want {
|
|
t.Fatalf("unexpected merged order: got %s want %s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestParseCoverageRange_ErrorBranches(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
_, _, _, err := parseCoverageRange("missing-colon")
|
|
if err == nil {
|
|
t.Fatal("expected error for missing colon")
|
|
}
|
|
|
|
_, _, _, err = parseCoverageRange("file.go:10.1")
|
|
if err == nil {
|
|
t.Fatal("expected error for missing end coordinate")
|
|
}
|
|
|
|
_, _, _, err = parseCoverageRange("file.go:bad.1,10.1")
|
|
if err == nil {
|
|
t.Fatal("expected error for bad start line")
|
|
}
|
|
|
|
_, _, _, err = parseCoverageRange("file.go:10.1,9.1")
|
|
if err == nil {
|
|
t.Fatal("expected error for reversed range")
|
|
}
|
|
}
|
|
|
|
func TestSortedWarnings_FiltersBlanksAndSorts(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
sorted := SortedWarnings([]string{"z warning", "", " ", "a warning"})
|
|
got := strings.Join(sorted, ",")
|
|
want := "a warning,z warning"
|
|
if got != want {
|
|
t.Fatalf("unexpected warnings ordering: got %q want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestNormalizePathsAndRanges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if got := normalizeGoCoveragePath("internal/service.go"); got != "backend/internal/service.go" {
|
|
t.Fatalf("unexpected normalized go path: %s", got)
|
|
}
|
|
|
|
if got := normalizeGoCoveragePath("/tmp/work/backend/internal/service.go"); got != "backend/internal/service.go" {
|
|
t.Fatalf("unexpected backend extraction path: %s", got)
|
|
}
|
|
|
|
frontend := normalizeFrontendCoveragePaths("/tmp/work/frontend/src/App.tsx")
|
|
if len(frontend) == 0 {
|
|
t.Fatal("expected frontend normalized paths")
|
|
}
|
|
|
|
ranges := formatLineRanges([]int{1, 2, 3, 7, 9, 10})
|
|
gotRanges := strings.Join(ranges, ",")
|
|
wantRanges := "1-3,7,9-10"
|
|
if gotRanges != wantRanges {
|
|
t.Fatalf("unexpected ranges: got %q want %q", gotRanges, wantRanges)
|
|
}
|
|
}
|
|
|
|
func TestScopeCoverageMergeAndStatus(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
merged := MergeScopeCoverage(
|
|
ScopeCoverage{ChangedLines: 4, CoveredLines: 3},
|
|
ScopeCoverage{ChangedLines: 0, CoveredLines: 0},
|
|
)
|
|
|
|
if merged.ChangedLines != 4 || merged.CoveredLines != 3 || merged.PatchCoveragePct != 75.0 {
|
|
t.Fatalf("unexpected merged scope: %+v", merged)
|
|
}
|
|
|
|
if status := ApplyStatus(merged, 70); status.Status != "pass" {
|
|
t.Fatalf("expected pass status, got %s", status.Status)
|
|
}
|
|
}
|
|
|
|
func TestParseCoverageProfiles_InvalidPath(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
_, err := ParseGoCoverageProfile(" ")
|
|
if err == nil {
|
|
t.Fatal("expected go profile path validation error")
|
|
}
|
|
|
|
_, err = ParseLCOVProfile("\t")
|
|
if err == nil {
|
|
t.Fatal("expected lcov profile path validation error")
|
|
}
|
|
}
|
|
|
|
func TestNormalizeFrontendCoveragePaths_EmptyInput(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
paths := normalizeFrontendCoveragePaths(" ")
|
|
if len(paths) == 0 {
|
|
t.Fatalf("expected normalized fallback paths, got %#v", paths)
|
|
}
|
|
}
|
|
|
|
func TestAddLine_IgnoresInvalidInputs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
set := make(FileLineSet)
|
|
addLine(set, "", 10)
|
|
addLine(set, "backend/internal/x.go", 0)
|
|
if len(set) != 0 {
|
|
t.Fatalf("expected no entries for invalid addLine input, got %#v", set)
|
|
}
|
|
}
|