func load(yamlStr string) (*TLSConfig, error) {
var cfg TLSConfig
config, err := common.NewConfigWithYAML([]byte(yamlStr), "")
if err != nil {
return nil, err
}
if err = config.Unpack(&cfg); err != nil {
return nil, err
}
return &cfg, nil
}
func load(t *testing.T, in string) cfg.FilebeatConfig {
yaml, err := common.NewConfigWithYAML([]byte(in), "")
if err != nil {
t.Fatalf("Failed to parse config input: %v", err)
}
var config cfg.FilebeatConfig
err = yaml.Unpack(&config)
if err != nil {
t.Fatalf("Failed to unpack config: %v", err)
}
return config
}
func load(t *testing.T, in string) *cfg.Config {
yaml, err := common.NewConfigWithYAML([]byte(in), "")
if err != nil {
t.Fatalf("Failed to parse config input: %v", err)
}
tmpConfig := struct {
Filebeat cfg.Config
}{cfg.DefaultConfig}
err = yaml.Unpack(&tmpConfig)
if err != nil {
t.Fatalf("Failed to unpack config: %v", err)
}
return &tmpConfig.Filebeat
}
func TestCertificateFails(t *testing.T) {
tests := []struct {
title string
yaml string
}{
{
"certificate without key",
"certificate: mycert.pem",
},
{
"key without certificate",
"key: mycert.key",
},
{
"unknown cipher suite",
"cipher_suites: ['unknown cipher suite']",
},
{
"unknown version",
"supported_protocols: [UnknwonTLSv1.1]",
},
{
"unknown curve type",
"curve_types: ['unknown curve type']",
},
}
for i, test := range tests {
t.Logf("run test (%v): %v", i, test.title)
config, err := common.NewConfigWithYAML([]byte(test.yaml), "")
if err != nil {
t.Error(err)
continue
}
// one must fail: validators on Unpack or transformation to *tls.Config
var tlscfg TLSConfig
if err = config.Unpack(&tlscfg); err != nil {
t.Log(err)
continue
}
_, err = LoadTLSConfig(&tlscfg)
t.Log(err)
assert.Error(t, err)
}
}
// Load reads the configuration from a YAML file structure. If path is empty
// this method reads from the configuration file specified by the '-c' command
// line flag.
func Load(path string) (*common.Config, error) {
if path == "" {
path = *configfile
}
fileContent, err := ioutil.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read %s: %v", path, err)
}
fileContent, err = expandEnv(filepath.Base(path), fileContent)
if err != nil {
return nil, err
}
config, err := common.NewConfigWithYAML(fileContent, path)
if err != nil {
return nil, fmt.Errorf("YAML config parsing failed on %s: %v", path, err)
}
return config, nil
}
func TestSelectorInitFail(t *testing.T) {
tests := []struct {
title string
config string
}{
{
"keys missing",
`test: no key`,
},
{
"invalid keys type",
`keys: 5`,
},
{
"invaid keys element type",
`keys: [5]`,
},
{
"invalid key type",
`key: {}`,
},
{
"missing key in list",
`keys: [default: value]`,
},
{
"invalid key type in list",
`keys: [key: {}]`,
},
{
"fail on invalid format string",
`key: '%{[abc}'`,
},
{
"fail on invalid format string in list",
`keys: [key: '%{[abc}']`,
},
{
"default value type mismatch",
`keys: [{key: ok, default: {}}]`,
},
{
"mappings type mismatch",
`keys:
- key: '%{[k]}'
mappings: {v: {}}`,
},
{
"condition empty",
`keys:
- key: value
when:`,
},
}
for i, test := range tests {
t.Logf("run (%v): %v", i, test.title)
cfg, err := common.NewConfigWithYAML([]byte(test.config), "test")
if err != nil {
t.Error(err)
continue
}
_, err = BuildSelectorFromConfig(cfg, Settings{
Key: "key",
MultiKey: "keys",
EnableSingleOnly: true,
FailEmpty: true,
})
assert.Error(t, err)
t.Log(err)
}
}
func TestSelector(t *testing.T) {
tests := []struct {
title string
config string
event common.MapStr
expected string
}{
{
"constant key",
`key: value`,
common.MapStr{},
"value",
},
{
"format string key",
`key: '%{[key]}'`,
common.MapStr{"key": "value"},
"value",
},
{
"key with empty keys",
`{key: value, keys: }`,
common.MapStr{},
"value",
},
{
"constant in multi key",
`keys: [key: 'value']`,
common.MapStr{},
"value",
},
{
"format string in multi key",
`keys: [key: '%{[key]}']`,
common.MapStr{"key": "value"},
"value",
},
{
"missing format string key with default in rule",
`keys:
- key: '%{[key]}'
default: value`,
common.MapStr{},
"value",
},
{
"empty format string key with default in rule",
`keys:
- key: '%{[key]}'
default: value`,
common.MapStr{"key": ""},
"value",
},
{
"missing format string key with constant in next rule",
`keys:
- key: '%{[key]}'
- key: value`,
common.MapStr{},
"value",
},
{
"missing format string key with constant in top-level rule",
`{ key: value, keys: [key: '%{[key]}']}`,
common.MapStr{},
"value",
},
{
"apply mapping",
`keys:
- key: '%{[key]}'
mappings:
v: value`,
common.MapStr{"key": "v"},
"value",
},
{
"apply mapping with default on empty key",
`keys:
- key: '%{[key]}'
default: value
mappings:
v: 'v'`,
common.MapStr{"key": ""},
"value",
},
{
"apply mapping with default on empty lookup",
`keys:
- key: '%{[key]}'
default: value
mappings:
v: ''`,
common.MapStr{"key": "v"},
"value",
},
{
"apply mapping without match",
`keys:
- key: '%{[key]}'
mappings:
v: ''
- key: value`,
common.MapStr{"key": "x"},
"value",
},
{
"mapping with constant key",
`keys:
- key: k
mappings:
k: value`,
common.MapStr{},
"value",
},
{
"mapping with missing constant key",
`keys:
- key: unknown
mappings: {k: wrong}
- key: value`,
common.MapStr{},
"value",
},
{
"mapping with missing constant key, but default",
`keys:
- key: unknown
default: value
mappings: {k: wrong}`,
common.MapStr{},
"value",
},
{
"matching condition",
`keys:
- key: value
when.equals.test: test`,
common.MapStr{"test": "test"},
"value",
},
{
"failing condition",
`keys:
- key: wrong
when.equals.test: test
- key: value`,
common.MapStr{"test": "x"},
"value",
},
}
for i, test := range tests {
t.Logf("run (%v): %v", i, test.title)
cfg, err := common.NewConfigWithYAML([]byte(test.config), "test")
if err != nil {
t.Error(err)
continue
}
sel, err := BuildSelectorFromConfig(cfg, Settings{
Key: "key",
MultiKey: "keys",
EnableSingleOnly: true,
FailEmpty: true,
})
if err != nil {
t.Error(err)
continue
}
actual, err := sel.Select(test.event)
if err != nil {
t.Error(err)
continue
}
assert.Equal(t, test.expected, actual)
}
}