FilesExpand file tree

main

/

test_super_linter_scope.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

166 lines (145 loc) · 7.81 KB

main

/

test_super_linter_scope.py

Copy path

Top

File metadata and controls

• Code
• Blame

166 lines (145 loc) · 7.81 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

"""Regression checks for the Super Linter GO_MODULES directory selection."""

import re

import unittest

from pathlib import Path

from summarize_super_linter import summarize_log

ROOT = Path(__file__).resolve().parent.parent

SOURCE = ROOT / ".github/workflows/super-linter.md"

LOCK = ROOT / ".github/workflows/super-linter.lock.yml"

class SuperLinterScopeTests(unittest.TestCase):

def setUp(self):

self.source = SOURCE.read_text()

match = re.search(r'FILTER_REGEX_EXCLUDE: "([^"\n]+)"', self.source)

self.assertIsNotNone(match)

self.pattern = match.group(1)

def excluded(self, path):

# Pinned super-linter filters full file paths before queuing their

# containing directories in file-array-GO_MODULES.

return re.search(self.pattern, path) is not None

def test_deliberate_fixtures_and_empty_manifest_are_excluded(self):

paths = [

".github/workflows/go.mod",

"pkg/linters/appendbytestring/testdata/src/appendbytestring/appendbytestring.go",

"pkg/linters/bufioscannererunchecked/testdata/src/basic/bad.go",

"pkg/linters/internal/resourcetracker/testdata/src/resourcetracker/bad.go",

"pkg/linters/internal/analyzer/deep/testdata/src/basic/bad.go",

"super-linter-output/report.go",

]

for path in paths:

for prefix in ("", "/github/workspace/"):

with self.subTest(path=prefix + path):

self.assertTrue(self.excluded(prefix + path))

fixtures = list((ROOT / "pkg/linters").glob("**/testdata/**/*.go"))

self.assertGreater(len(fixtures), 0)

for fixture in fixtures:

self.assertTrue(self.excluded(str(fixture.relative_to(ROOT))), fixture)

self.assertEqual(list((ROOT / ".github/workflows").rglob("*.go")), [])

def test_real_code_tests_and_module_remain_included(self):

paths = [

"go.mod",

"cmd/gh-aw/main.go",

"pkg/logger/logger.go",

"pkg/workflow/checkout_config_parser.go",

"pkg/linters/appendbytestring/appendbytestring.go",

"pkg/linters/appendbytestring/appendbytestring_test.go",

".github/scripts/purelock/purity_scan.go",

"scripts/lint_error_messages_test.go",

"pkg/linters/example/testdata_helpers.go",

"pkg/linters/internal/resourcetracker/resourcetracker.go",

"pkg/linters/internal/resourcetracker/resourcetracker_test.go",

".github/workflows/go.mod.backup",

]

for path in paths:

for prefix in ("", "/github/workspace/"):

with self.subTest(path=prefix + path):

self.assertFalse(self.excluded(prefix + path))

def test_generated_lock_preserves_scope_and_reports_failures(self):

lock = LOCK.read_text()

self.assertIn("FILTER_REGEX_EXCLUDE: " + self.pattern, lock)

for text in (self.source, lock):

self.assertIn('VALIDATE_GO_MODULES: "true"', text)

self.assertIn("continue-on-error: true", text)

self.assertIn("${{ steps.super-linter.outcome }}", text)

self.assertIn("Super-linter did not produce a nonempty log", text)

self.assertIn("/tmp/super-linter-result.txt", text)

self.assertIn("if-no-files-found: error", text)

self.assertNotIn("GO_CONFIG_FILE:", self.source)

self.assertNotIn("LINTER_RULES_PATH:", self.source)

self.assertIn("twenty examples total", self.source)

self.assertIn("does not establish an exploitable vulnerability", self.source)

self.assertNotIn("[Include the full linter output here]", self.source)

self.assertIn("golangci-lint@v2.15.0", self.source)

self.assertIn("GOTOOLCHAIN=\"$(go env GOVERSION)\"", self.source)

self.assertIn("exec /action/lib/linter.sh", self.source)

self.assertIn("super-linter:v9.0.0@sha256:", self.source)

self.assertIn("max-retries: 1", self.source)

self.assertIn("COPILOT_MODEL: mai-code-1.1-flash", lock)

for text in (self.source, lock):

self.assertIn("/tmp/super-linter-summary.json", text)

self.assertIn("analysis incomplete", self.source)

class SuperLinterSummaryTests(unittest.TestCase):

def test_counts_all_diagnostics_and_nested_fixtures_once(self):

typecheck = (

"pkg/console/render.go:7:2: could not import reflect "

"(export data version 5 is greater than maximum supported version 4) (typecheck)"

)

fixture = (

"pkg/linters/internal/resourcetracker/testdata/src/basic/bad.go:11:2: "

"Error return value is not checked (errcheck)"

)

source = "pkg/example/example.go:5:2: integer overflow conversion (gosec)"

summary = summarize_log("\n".join([typecheck, fixture, source, typecheck]), "failure")

self.assertEqual(summary["diagnostic_count"], 3)

self.assertEqual(summary["counts"], {"typecheck": 1, "fixtures": 1, "source": 1})

self.assertFalse(summary["coverage_complete"])

self.assertEqual(summary["title_suffix"], "analysis incomplete")

def test_uses_file_line_linter_message_identity_and_strips_ansi(self):

diagnostic = "pkg/example/example.go:5:2: unsafe conversion (gosec)"

summary = summarize_log(

"\x1b[31m" + diagnostic + "\x1b[0m\n" + diagnostic.replace(":5:2:", ":5:9:"),

"failure",

)

self.assertEqual(summary["diagnostic_count"], 1)

self.assertEqual(summary["counts"]["source"], 1)

self.assertFalse(summary["coverage_complete"])

def test_source_findings_do_not_hide_unrecognized_analyzer_failure(self):

summary = summarize_log(

"pkg/example/example.go:5:2: unsafe conversion (gosec)\n"

"[ERROR] can't run linter goanalysis_metalinter: unexpected analyzer failure",

"failure",

)

self.assertEqual(summary["counts"]["source"], 1)

self.assertFalse(summary["coverage_complete"])

self.assertEqual(summary["title_suffix"], "analysis incomplete")

def test_unknown_custom_linter_warning_prevents_clean_verdict(self):

summary = summarize_log(

'level=warning msg="Found unknown linters in //nolint directives: resourcetrackertest"',

"success",

)

self.assertEqual(summary["tooling_message_count"], 1)

self.assertFalse(summary["coverage_complete"])

def test_failed_run_without_diagnostics_is_not_clean(self):

summary = summarize_log("[ERROR] Super-linter failed before startup", "failure")

self.assertFalse(summary["coverage_complete"])

self.assertEqual(summary["title_suffix"], "analysis incomplete")

def test_clean_run_requires_success_and_complete_coverage(self):

summary = summarize_log("[INFO] All files linted successfully", "success")

self.assertTrue(summary["coverage_complete"])

self.assertEqual(summary["title_suffix"], "0 source findings")

def test_examples_are_bounded_without_losing_counts(self):

diagnostics = [

f"pkg/example/example.go:{line}:2: diagnostic (linter{linter})"

for linter in range(10)

for line in range(1, 6)

]

summary = summarize_log("\n".join(diagnostics), "failure")

self.assertEqual(summary["diagnostic_count"], 50)

self.assertEqual(sum(len(group["examples"]) for group in summary["groups"]), 20)

self.assertTrue(all(len(group["examples"]) <= 3 for group in summary["groups"]))

def test_rejects_empty_log_and_unknown_outcome(self):

with self.assertRaisesRegex(ValueError, "must not be empty"):

summarize_log(" \n", "success")

with self.assertRaisesRegex(ValueError, "outcome"):

summarize_log("[INFO] starting", "cancelled")

if __name__ == "__main__":

unittest.main()