Function testOneParser

pkg/parser/parsing_test.go:99–153

(t require.TestingT, pctx *UnixParserCtx, ectx EnricherCtx, dir string, b *testing.B)

}

func testOneParser(t require.TestingT, pctx *UnixParserCtx, ectx EnricherCtx, dir string, b *testing.B) error {
	var (
		pnodes        []Node
		parserConfigs []Stagefile
	)

	log.Warningf("testing %s", dir)

	parserCfgFile := filepath.Join(dir, "parsers.yaml")

	cfg, err := os.ReadFile(parserCfgFile)
	if err != nil {
		return fmt.Errorf("failed opening %s: %w", parserCfgFile, err)
	}

	tmpl, err := template.New("test").Parse(string(cfg))
	if err != nil {
		return fmt.Errorf("failed to parse template %s: %w", cfg, err)
	}

	var out bytes.Buffer

	err = tmpl.Execute(&out, map[string]string{"TestDirectory": dir})
	if err != nil {
		panic(err)
	}

	if err = yaml.UnmarshalStrict(out.Bytes(), &parserConfigs); err != nil {
		return fmt.Errorf("failed to parse %s: %w", parserCfgFile, err)
	}

	pnodes, err = LoadStages(parserConfigs, pctx, ectx)
	if err != nil {
		return fmt.Errorf("unable to load parser config: %w", err)
	}

	// TBD: Load post overflows
	// func testFile(t *testing.T, file string, pctx UnixParserCtx, nodes []Node) bool {
	parserTestFile := filepath.Join(dir, "test.yaml")
	tests := loadTestFile(t, parserTestFile)
	count := 1

	if b != nil {
		count = b.N
		b.ResetTimer()
	}

	for range count {
		if !testFile(t, tests, *pctx, pnodes) {
			return errors.New("test failed")
		}
	}

	return nil
}

// prepTests is going to do the initialisation of parser : it's going to load enrichment plugins and load the patterns. This is done here so that we don't redo it for each test
func prepTests(t require.TestingT) (*UnixParserCtx, EnricherCtx) {