128 lines
2.8 KiB
Go
128 lines
2.8 KiB
Go
package notify_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
n "git.st8l.com/luxolus/kdnotify/schema/notify"
|
|
"git.st8l.com/luxolus/kdnotify/schema/notify/prio"
|
|
"git.st8l.com/luxolus/kdnotify/schema/notify/state"
|
|
"git.st8l.com/luxolus/kdnotify/schema/notify/ty"
|
|
)
|
|
|
|
func Test_ParseMessage(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
Name string
|
|
Message string
|
|
Expected *n.Message
|
|
ShouldError bool
|
|
HandlerFunc func(t *testing.T, expected, actual *n.Message) bool
|
|
}{
|
|
{
|
|
Name: "Empty",
|
|
Message: "",
|
|
ShouldError: true,
|
|
},
|
|
{
|
|
Name: "Simple",
|
|
Message: `INSTANCE foo_instance MASTER`,
|
|
Expected: &n.Message{
|
|
Type: ty.INSTANCE,
|
|
State: state.MASTER,
|
|
Instance: "foo_instance",
|
|
},
|
|
},
|
|
{
|
|
Name: "WithPriority",
|
|
Message: `INSTANCE foo_instance BACKUP 100`,
|
|
Expected: &n.Message{
|
|
Type: ty.INSTANCE,
|
|
State: state.BACKUP,
|
|
Instance: "foo_instance",
|
|
Priority: prio.Priority(100),
|
|
},
|
|
},
|
|
{
|
|
Name: "Trailing",
|
|
Message: `INSTANCE foo_instance MASTER 255 othe!r ran@##@dom ^garbage%`,
|
|
Expected: &n.Message{
|
|
Type: ty.INSTANCE,
|
|
State: state.MASTER,
|
|
Instance: "foo_instance",
|
|
Priority: prio.MASTER,
|
|
},
|
|
},
|
|
{
|
|
Name: "DirtyInstance",
|
|
Message: `INSTANCE "'"foo_instance"'" MASTER`,
|
|
Expected: &n.Message{
|
|
Type: ty.INSTANCE,
|
|
State: state.MASTER,
|
|
Instance: "foo_instance",
|
|
},
|
|
},
|
|
{
|
|
Name: "Group",
|
|
Message: `GROUP "''baz_group''" STOP`,
|
|
Expected: &n.Message{
|
|
Type: ty.GROUP,
|
|
State: state.STOP,
|
|
Instance: "baz_group",
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, test := range cases {
|
|
test := test // Avoid closure capture by ref
|
|
tname := fmt.Sprintf("%s@%d:%d", test.Name, i+1, len(cases))
|
|
|
|
t.Run(tname, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if test.HandlerFunc == nil {
|
|
test.HandlerFunc = Noop[string]
|
|
if test.Expected != nil {
|
|
test.HandlerFunc = ExpectMessage
|
|
if test.ShouldError {
|
|
test.HandlerFunc = ExpectNotEqual[*n.Message]
|
|
}
|
|
}
|
|
}
|
|
|
|
actual, err := n.ParseMessage(test.Message)
|
|
if test.ShouldError && err != nil {
|
|
return
|
|
} else if assert.NoError(t, err) {
|
|
test.HandlerFunc(t, test.Expected, &actual)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func ExpectMessage(t *testing.T, expected, actual *n.Message) bool {
|
|
return assert.Equal(t, expected, actual)
|
|
}
|
|
|
|
func ExpectVrrp(t *testing.T, expected, actual *n.Message) bool {
|
|
e, err := n.NewVrrp(*expected)
|
|
require.NoError(t, err)
|
|
|
|
a, err := n.NewVrrp(*actual)
|
|
assert.NoError(t, err)
|
|
|
|
return assert.Equal(t, e, a)
|
|
}
|
|
|
|
func ExpectNotEqual[T any](t *testing.T, expected, actual T) bool {
|
|
return assert.NotEqual(t, expected, actual)
|
|
}
|
|
|
|
func Noop[T any](_ *testing.T, _, _ *n.Message) bool {
|
|
return true
|
|
}
|