Adding test case to handle folder of rules/ruleset.yaml and dir's

Signed-off-by: Shawn Hurley <shawn@hurley.page>

Author: shawn-hurley

parser/rule_parser.go

@@ -2,6 +2,7 @@ package parser
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"maps"
 	"os"
@@ -37,21 +38,6 @@ func (e MissingProviderError) Error() string {
 	return fmt.Sprintf("unable to find provider for: %v", e.Provider)
 }
 
-type parserErrors struct {
-	errs []error
-}
-
-func (e parserErrors) Error() string {
-	s := ""
-	for i, e := range e.errs {
-		if i == 0 {
-			s = e.Error()
-		}
-		s = fmt.Sprintf("%s\n%s", s, e.Error())
-	}
-	return s
-}
-
 type ruleParseReturn struct {
 	rules           []engine.Rule
 	conditionsByCap map[string][]provider.ConditionsByCap
@@ -136,21 +122,21 @@ func (r *RuleParser) LoadRules(filepath string) ([]engine.RuleSet, map[string]pr
 	}
 	var ruleSet *engine.RuleSet
 	rules := []engine.Rule{}
-	parserErr := &parserErrors{}
+	var parseErr error
 	ruleParserWG := sync.WaitGroup{}
 	ruleLoadChan := make(chan ruleParseReturn, 10)
 
-	loadCtx, _ := context.WithTimeout(context.Background(), 5*time.Minute)
+	loadCtx, cancelFunc := context.WithTimeout(context.Background(), 5*time.Minute)
 	for _, f := range files {
 		info, err := os.Stat(path.Join(filepath, f.Name()))
 		if err != nil {
-			parserErr.errs = append(parserErr.errs, err)
+			parseErr = errors.Join(parseErr, err)
 			continue
 		}
 		if info.IsDir() {
 			r, m, provConditions, err := r.LoadRules(path.Join(filepath, f.Name()))
 			if err != nil {
-				parserErr.errs = append(parserErr.errs, err)
+				parseErr = errors.Join(parseErr, err)
 				continue
 			}
 			ruleSets = append(ruleSets, r...)
@@ -211,7 +197,7 @@ func (r *RuleParser) LoadRules(filepath string) ([]engine.RuleSet, map[string]pr
 				continue
 			}
 			if load.err != nil {
-				parserErr.errs = append(parserErr.errs, load.err)
+				parseErr = errors.Join(parseErr, err)
 				ruleParserWG.Done()
 				continue
 			}
@@ -242,18 +228,16 @@ func (r *RuleParser) LoadRules(filepath string) ([]engine.RuleSet, map[string]pr
 			}
 			if ok, err := r.Selector.Matches(meta); !ok && err == nil {
 				r.Log.V(6).Info("ruleset does not have any rules that match selector, filtering out", "ruleSet", ruleSet.Name)
-				return nil, nil, nil, nil
+				cancelFunc()
+				return ruleSets, clientMap, providerConditions, parseErr
 			}
 		}
 
 		ruleSet.Rules = rules
 		ruleSets = append(ruleSets, *ruleSet)
 	}
-	// Return nil if there are no captured errors
-	if len(parserErr.errs) == 0 {
-		return ruleSets, clientMap, providerConditions, nil
-	}
-	return ruleSets, clientMap, providerConditions, parserErr
+	cancelFunc()
+	return ruleSets, clientMap, providerConditions, parseErr
 }
 
 func (r *RuleParser) LoadRule(filepath string) ([]engine.Rule, map[string]provider.InternalProviderClient, map[string][]provider.ConditionsByCap, error) {

parser/rule_parser_test.go

@@ -653,6 +653,113 @@ func TestLoadRules(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name:         "folder of rules ruleset",
+			testFileName: "folder-of-rules-ruleset",
+			providerNameClient: map[string]provider.InternalProviderClient{
+				"builtin": testProvider{
+					caps: []provider.Capability{{
+						Name: "file",
+					}},
+				},
+				"notadded": testProvider{
+					caps: []provider.Capability{{
+						Name: "fake",
+					}},
+				},
+			},
+			ExpectedRuleSet: map[string]engine.RuleSet{
+				"folder-of-rules-rulesets": {
+					Rules: []engine.Rule{
+						{
+							RuleMeta: engine.RuleMeta{
+								RuleID:   "file-001",
+								Effort:   &effort,
+								Category: &konveyor.Potential,
+							},
+							Perform: engine.Perform{
+								Message: engine.Message{
+									Text:  &allGoFiles,
+									Links: []konveyor.Link{},
+								},
+							},
+							When: engine.ConditionEntry{},
+						},
+					},
+				},
+				"file-ruleset-a": {
+					Rules: []engine.Rule{
+						{
+							RuleMeta: engine.RuleMeta{
+								RuleID:      "file-001",
+								Description: "",
+								Category:    &konveyor.Potential,
+							},
+							Perform: engine.Perform{Message: engine.Message{Text: &allGoFiles, Links: []konveyor.Link{}}},
+							When:    engine.ConditionEntry{},
+						},
+					},
+				},
+				"file-ruleset-b": {
+					Rules: []engine.Rule{
+						{
+							RuleMeta: engine.RuleMeta{RuleID: "file-001",
+								Description: "",
+								Category:    &konveyor.Potential,
+							},
+							Perform: engine.Perform{Message: engine.Message{Text: &allGoFiles, Links: []konveyor.Link{}}},
+							When:    engine.ConditionEntry{},
+						},
+					},
+				},
+			},
+			ExpectedProvider: map[string]provider.InternalProviderClient{
+				"builtin": testProvider{
+					caps: []provider.Capability{{
+						Name: "file",
+					}},
+				},
+			},
+		},
+		{
+			Name:         "folder of rules ruleset filter",
+			testFileName: "folder-of-rules-ruleset",
+			providerNameClient: map[string]provider.InternalProviderClient{
+				"builtin": testProvider{
+					caps: []provider.Capability{{
+						Name: "file",
+					}},
+				},
+				"notadded": testProvider{
+					caps: []provider.Capability{{
+						Name: "fake",
+					}},
+				},
+			},
+			ExpectedRuleSet: map[string]engine.RuleSet{
+				"file-ruleset-a": {
+					Rules: []engine.Rule{
+						{
+							RuleMeta: engine.RuleMeta{
+								RuleID:      "file-001",
+								Description: "",
+								Category:    &konveyor.Potential,
+							},
+							Perform: engine.Perform{Message: engine.Message{Text: &allGoFiles, Links: []konveyor.Link{}}},
+							When:    engine.ConditionEntry{},
+						},
+					},
+				},
+			},
+			ExpectedProvider: map[string]provider.InternalProviderClient{
+				"builtin": testProvider{
+					caps: []provider.Capability{{
+						Name: "file",
+					}},
+				},
+			},
+			Selector: "test=filter",
+		},
 		{
 			Name:         "handle not-valid category",
 			testFileName: "invalid-category.yaml",
@@ -1053,7 +1160,7 @@ func TestLoadRules(t *testing.T) {
 						compareWhens(expectedRule.When, rule.When, t)
 					}
 					if !foundRule {
-						t.Errorf("not have matching rule go: %#v, expected rules: %#v", rule, expectedSet.Rules)
+						t.Errorf("not have matching rule go: %#v\nin ruleset: %v\nexpected rules: %#v", rule, ruleSet.Name, expectedSet.Rules)
 					}
 				}
 				// We will test the conditions getter by itself.

parser/testdata/folder-of-rules-ruleset/rule-simple-default.yaml

@@ -0,0 +1,7 @@
+---
+- message: all go files
+  ruleID: file-001
+  category: potential
+  effort: 3
+  when:
+    builtin.file: "*.go"

parser/testdata/folder-of-rules-ruleset/ruleset-a/rule-simple-default.yaml

@@ -0,0 +1,5 @@
+---
+- message: all go files
+  ruleID: file-001
+  when:
+    builtin.file: "*.go"

parser/testdata/folder-of-rules-ruleset/ruleset-a/ruleset.yaml

@@ -0,0 +1,4 @@
+name: "file-ruleset-a"
+description: "testing"
+labels:
+  - test=filter

parser/testdata/folder-of-rules-ruleset/ruleset-b/rule-simple-default.yaml

@@ -0,0 +1,5 @@
+---
+- message: all go files
+  ruleID: file-001
+  when:
+    builtin.file: "*.go"

parser/testdata/folder-of-rules-ruleset/ruleset-b/ruleset.yaml

@@ -0,0 +1,2 @@
+name: "file-ruleset-b"
+description: "testing"

parser/testdata/folder-of-rules-ruleset/ruleset.yaml

@@ -0,0 +1,2 @@
+name: "folder-of-rules-rulesets"
+description: "testing"