github.com/vanstinator/golangci-lint@v0.0.0-20240223191551-cc572f00d9d1/pkg/result/processors/exclude_rules_test.go (about) 1 package processors 2 3 import ( 4 "path" 5 "path/filepath" 6 "testing" 7 8 "github.com/stretchr/testify/assert" 9 10 "github.com/vanstinator/golangci-lint/pkg/fsutils" 11 "github.com/vanstinator/golangci-lint/pkg/result" 12 ) 13 14 func TestExcludeRulesMultiple(t *testing.T) { 15 lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) 16 files := fsutils.NewFiles(lineCache, "") 17 18 p := NewExcludeRules([]ExcludeRule{ 19 { 20 BaseRule: BaseRule{ 21 Text: "^exclude$", 22 Linters: []string{"linter"}, 23 }, 24 }, 25 { 26 BaseRule: BaseRule{ 27 Linters: []string{"testlinter"}, 28 Path: `_test\.go`, 29 }, 30 }, 31 { 32 BaseRule: BaseRule{ 33 Text: "^testonly$", 34 Path: `_test\.go`, 35 }, 36 }, 37 { 38 BaseRule: BaseRule{ 39 Text: "^nontestonly$", 40 PathExcept: `_test\.go`, 41 }, 42 }, 43 { 44 BaseRule: BaseRule{ 45 Source: "^//go:generate ", 46 Linters: []string{"lll"}, 47 }, 48 }, 49 }, files, nil) 50 51 //nolint:dupl 52 cases := []issueTestCase{ 53 {Path: "e.go", Text: "exclude", Linter: "linter"}, 54 {Path: "e.go", Text: "some", Linter: "linter"}, 55 {Path: "e_test.go", Text: "normal", Linter: "testlinter"}, 56 {Path: "e_Test.go", Text: "normal", Linter: "testlinter"}, 57 {Path: "e_test.go", Text: "another", Linter: "linter"}, 58 {Path: "e_test.go", Text: "testonly", Linter: "linter"}, 59 {Path: "e.go", Text: "nontestonly", Linter: "linter"}, 60 {Path: "e_test.go", Text: "nontestonly", Linter: "linter"}, 61 {Path: filepath.Join("testdata", "exclude_rules.go"), Line: 3, Linter: "lll"}, 62 } 63 var issues []result.Issue 64 for _, c := range cases { 65 issues = append(issues, newIssueFromIssueTestCase(c)) 66 } 67 processedIssues := process(t, p, issues...) 68 var resultingCases []issueTestCase 69 for _, i := range processedIssues { 70 resultingCases = append(resultingCases, issueTestCase{ 71 Path: i.FilePath(), 72 Linter: i.FromLinter, 73 Text: i.Text, 74 Line: i.Line(), 75 }) 76 } 77 expectedCases := []issueTestCase{ 78 {Path: "e.go", Text: "some", Linter: "linter"}, 79 {Path: "e_Test.go", Text: "normal", Linter: "testlinter"}, 80 {Path: "e_test.go", Text: "another", Linter: "linter"}, 81 {Path: "e_test.go", Text: "nontestonly", Linter: "linter"}, 82 } 83 assert.Equal(t, expectedCases, resultingCases) 84 } 85 86 func TestExcludeRulesPathPrefix(t *testing.T) { 87 lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) 88 pathPrefix := path.Join("some", "dir") 89 files := fsutils.NewFiles(lineCache, pathPrefix) 90 91 p := NewExcludeRules([]ExcludeRule{ 92 { 93 BaseRule: BaseRule{ 94 Path: `some/dir/e\.go`, 95 }, 96 }, 97 }, files, nil) 98 99 cases := []issueTestCase{ 100 {Path: "e.go"}, 101 {Path: "other.go"}, 102 } 103 var issues []result.Issue 104 for _, c := range cases { 105 issues = append(issues, newIssueFromIssueTestCase(c)) 106 } 107 processedIssues := process(t, p, issues...) 108 var resultingCases []issueTestCase 109 for _, i := range processedIssues { 110 resultingCases = append(resultingCases, issueTestCase{ 111 Path: i.FilePath(), 112 Linter: i.FromLinter, 113 Text: i.Text, 114 Line: i.Line(), 115 }) 116 } 117 expectedCases := []issueTestCase{ 118 {Path: "other.go"}, 119 } 120 assert.Equal(t, expectedCases, resultingCases) 121 } 122 123 func TestExcludeRulesText(t *testing.T) { 124 p := NewExcludeRules([]ExcludeRule{ 125 { 126 BaseRule: BaseRule{ 127 Text: "^exclude$", 128 Linters: []string{"linter"}, 129 }, 130 }, 131 }, nil, nil) 132 texts := []string{"excLude", "1", "", "exclud", "notexclude"} 133 var issues []result.Issue 134 for _, t := range texts { 135 issues = append(issues, result.Issue{ 136 Text: t, 137 FromLinter: "linter", 138 }) 139 } 140 141 processedIssues := process(t, p, issues...) 142 assert.Len(t, processedIssues, len(issues)-1) 143 144 var processedTexts []string 145 for _, i := range processedIssues { 146 processedTexts = append(processedTexts, i.Text) 147 } 148 assert.Equal(t, texts[1:], processedTexts) 149 } 150 151 func TestExcludeRulesEmpty(t *testing.T) { 152 processAssertSame(t, NewExcludeRules(nil, nil, nil), newIssueFromTextTestCase("test")) 153 } 154 155 func TestExcludeRulesCaseSensitiveMultiple(t *testing.T) { 156 lineCache := fsutils.NewLineCache(fsutils.NewFileCache()) 157 files := fsutils.NewFiles(lineCache, "") 158 p := NewExcludeRulesCaseSensitive([]ExcludeRule{ 159 { 160 BaseRule: BaseRule{ 161 Text: "^exclude$", 162 Linters: []string{"linter"}, 163 }, 164 }, 165 { 166 BaseRule: BaseRule{ 167 Linters: []string{"testlinter"}, 168 Path: `_test\.go`, 169 }, 170 }, 171 { 172 BaseRule: BaseRule{ 173 Text: "^testonly$", 174 Path: `_test\.go`, 175 }, 176 }, 177 { 178 BaseRule: BaseRule{ 179 Source: "^//go:generate ", 180 Linters: []string{"lll"}, 181 }, 182 }, 183 }, files, nil) 184 185 //nolint:dupl 186 cases := []issueTestCase{ 187 {Path: "e.go", Text: "exclude", Linter: "linter"}, 188 {Path: "e.go", Text: "excLude", Linter: "linter"}, 189 {Path: "e.go", Text: "some", Linter: "linter"}, 190 {Path: "e_test.go", Text: "normal", Linter: "testlinter"}, 191 {Path: "e_Test.go", Text: "normal", Linter: "testlinter"}, 192 {Path: "e_test.go", Text: "another", Linter: "linter"}, 193 {Path: "e_test.go", Text: "testonly", Linter: "linter"}, 194 {Path: "e_test.go", Text: "testOnly", Linter: "linter"}, 195 {Path: filepath.Join("testdata", "exclude_rules_case_sensitive.go"), Line: 3, Linter: "lll"}, 196 } 197 var issues []result.Issue 198 for _, c := range cases { 199 issues = append(issues, newIssueFromIssueTestCase(c)) 200 } 201 processedIssues := process(t, p, issues...) 202 var resultingCases []issueTestCase 203 for _, i := range processedIssues { 204 resultingCases = append(resultingCases, issueTestCase{ 205 Path: i.FilePath(), 206 Linter: i.FromLinter, 207 Text: i.Text, 208 Line: i.Line(), 209 }) 210 } 211 expectedCases := []issueTestCase{ 212 {Path: "e.go", Text: "excLude", Linter: "linter"}, 213 {Path: "e.go", Text: "some", Linter: "linter"}, 214 {Path: "e_Test.go", Text: "normal", Linter: "testlinter"}, 215 {Path: "e_test.go", Text: "another", Linter: "linter"}, 216 {Path: "e_test.go", Text: "testOnly", Linter: "linter"}, 217 {Path: filepath.Join("testdata", "exclude_rules_case_sensitive.go"), Line: 3, Linter: "lll"}, 218 } 219 assert.Equal(t, expectedCases, resultingCases) 220 } 221 222 func TestExcludeRulesCaseSensitiveText(t *testing.T) { 223 p := NewExcludeRulesCaseSensitive([]ExcludeRule{ 224 { 225 BaseRule: BaseRule{ 226 Text: "^exclude$", 227 Linters: []string{"linter"}, 228 }, 229 }, 230 }, nil, nil) 231 texts := []string{"exclude", "excLude", "1", "", "exclud", "notexclude"} 232 var issues []result.Issue 233 for _, t := range texts { 234 issues = append(issues, result.Issue{ 235 Text: t, 236 FromLinter: "linter", 237 }) 238 } 239 240 processedIssues := process(t, p, issues...) 241 assert.Len(t, processedIssues, len(issues)-1) 242 243 var processedTexts []string 244 for _, i := range processedIssues { 245 processedTexts = append(processedTexts, i.Text) 246 } 247 assert.Equal(t, texts[1:], processedTexts) 248 } 249 250 func TestExcludeRulesCaseSensitiveEmpty(t *testing.T) { 251 processAssertSame(t, NewExcludeRulesCaseSensitive(nil, nil, nil), newIssueFromTextTestCase("test")) 252 }