498 lines
12 KiB
Go
498 lines
12 KiB
Go
package event
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/eventlogger"
|
|
"github.com/hashicorp/go-hclog"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func Test_InitSysEventer(t *testing.T) {
|
|
// this test and its subtests cannot be run in parallel because of it's
|
|
// dependency on the sysEventer
|
|
testConfig := TestEventerConfig(t, "InitSysEventer")
|
|
|
|
tests := []struct {
|
|
name string
|
|
log hclog.Logger
|
|
config EventerConfig
|
|
want *Eventer
|
|
wantErrIs error
|
|
}{
|
|
|
|
{
|
|
name: "missing-hclog",
|
|
config: testConfig.EventerConfig,
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "success",
|
|
config: testConfig.EventerConfig,
|
|
log: hclog.Default(),
|
|
want: &Eventer{
|
|
logger: hclog.Default(),
|
|
conf: testConfig.EventerConfig,
|
|
},
|
|
},
|
|
{
|
|
name: "success-with-default-config",
|
|
config: EventerConfig{},
|
|
log: hclog.Default(),
|
|
want: &Eventer{
|
|
logger: hclog.Default(),
|
|
conf: EventerConfig{
|
|
Sinks: []SinkConfig{
|
|
{
|
|
Name: "default",
|
|
EventTypes: []Type{EveryType},
|
|
Format: JSONSinkFormat,
|
|
SinkType: StdoutSink,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
defer TestResetSystEventer(t)
|
|
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
err := InitSysEventer(tt.log, tt.config)
|
|
got := SysEventer()
|
|
if tt.wantErrIs != nil {
|
|
require.Nil(got)
|
|
require.Error(err)
|
|
assert.ErrorIs(err, tt.wantErrIs)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
require.NotNil(got)
|
|
tt.want.broker = got.broker
|
|
tt.want.flushableNodes = got.flushableNodes
|
|
assert.Equal(tt.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEventer_writeObservation(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
testSetup := TestEventerConfig(t, "TestEventer_writeObservation")
|
|
eventer, err := NewEventer(hclog.Default(), testSetup.EventerConfig)
|
|
require.NoError(t, err)
|
|
|
|
testHeader := map[string]interface{}{"name": "header"}
|
|
testDetail := map[string]interface{}{"name": "details"}
|
|
testObservation, err := newObservation("Test_NewEventer", WithHeader(testHeader), WithDetails(testDetail))
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
broker broker
|
|
observation *observation
|
|
wantErrIs error
|
|
}{
|
|
{
|
|
name: "missing-observation",
|
|
broker: &testMockBroker{},
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "send-fails",
|
|
broker: &testMockBroker{errorOnSend: fmt.Errorf("%s: no msg: %w", "test", ErrIo)},
|
|
observation: testObservation,
|
|
wantErrIs: ErrMaxRetries,
|
|
},
|
|
{
|
|
name: "success",
|
|
broker: &testMockBroker{},
|
|
observation: testObservation,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
eventer.broker = tt.broker
|
|
|
|
err = eventer.writeObservation(ctx, tt.observation)
|
|
if tt.wantErrIs != nil {
|
|
require.Error(err)
|
|
assert.ErrorIs(err, tt.wantErrIs)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
})
|
|
}
|
|
t.Run("e2e", func(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
logger := hclog.New(&hclog.LoggerOptions{
|
|
Name: "test",
|
|
})
|
|
c := EventerConfig{
|
|
ObservationsEnabled: true,
|
|
}
|
|
// with no defined config, it will default to a stdout sink
|
|
e, err := NewEventer(logger, c)
|
|
require.NoError(err)
|
|
|
|
m := map[string]interface{}{
|
|
"name": "bar",
|
|
"list": []string{"1", "2"},
|
|
}
|
|
observationEvent, err := newObservation("Test_NewEventer", WithHeader(m))
|
|
require.NoError(err)
|
|
|
|
require.NoError(e.writeObservation(context.Background(), observationEvent))
|
|
})
|
|
}
|
|
|
|
func TestEventer_writeAudit(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
testSetup := TestEventerConfig(t, "Test_NewEventer")
|
|
eventer, err := NewEventer(hclog.Default(), testSetup.EventerConfig)
|
|
require.NoError(t, err)
|
|
|
|
testAudit, err := newAudit(
|
|
"TestEventer_writeAudit",
|
|
WithRequestInfo(TestRequestInfo(t)),
|
|
WithAuth(testAuth(t)),
|
|
WithRequest(testRequest(t)),
|
|
WithResponse(testResponse(t)))
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
broker broker
|
|
audit *audit
|
|
wantErrIs error
|
|
}{
|
|
{
|
|
name: "missing-audit",
|
|
broker: &testMockBroker{},
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "send-fails",
|
|
broker: &testMockBroker{errorOnSend: fmt.Errorf("%s: no msg: %w", "test", ErrIo)},
|
|
audit: testAudit,
|
|
wantErrIs: ErrIo,
|
|
},
|
|
{
|
|
name: "success",
|
|
broker: &testMockBroker{},
|
|
audit: testAudit,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
eventer.broker = tt.broker
|
|
|
|
err = eventer.writeAudit(ctx, tt.audit)
|
|
if tt.wantErrIs != nil {
|
|
require.Error(err)
|
|
assert.ErrorIs(err, tt.wantErrIs)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEventer_writeError(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
testSetup := TestEventerConfig(t, "Test_NewEventer")
|
|
eventer, er := NewEventer(hclog.Default(), testSetup.EventerConfig)
|
|
require.NoError(t, er)
|
|
|
|
testError, er := newError("TestEventer_writeError", fmt.Errorf("%s: no msg: test", ErrIo))
|
|
require.NoError(t, er)
|
|
|
|
tests := []struct {
|
|
name string
|
|
broker broker
|
|
err *err
|
|
wantErrIs error
|
|
}{
|
|
{
|
|
name: "missing-error",
|
|
broker: &testMockBroker{},
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "send-fails",
|
|
broker: &testMockBroker{errorOnSend: fmt.Errorf("%s: no msg: test", ErrIo)},
|
|
err: testError,
|
|
wantErrIs: ErrMaxRetries,
|
|
},
|
|
{
|
|
name: "success",
|
|
broker: &testMockBroker{},
|
|
err: testError,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
eventer.broker = tt.broker
|
|
|
|
err := eventer.writeError(ctx, tt.err)
|
|
if tt.wantErrIs != nil {
|
|
require.Error(err)
|
|
assert.ErrorIs(err, tt.wantErrIs)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_NewEventer(t *testing.T) {
|
|
t.Parallel()
|
|
testSetup := TestEventerConfig(t, "Test_NewEventer")
|
|
|
|
testSetupWithOpts := TestEventerConfig(t, "Test_NewEventer", testWithAuditSink(), testWithObservationSink(), testWithSysSink())
|
|
|
|
tests := []struct {
|
|
name string
|
|
config EventerConfig
|
|
opts []Option
|
|
logger hclog.Logger
|
|
want *Eventer
|
|
wantRegistered []string
|
|
wantPipelines []string
|
|
wantThresholds map[eventlogger.EventType]int
|
|
wantErrIs error
|
|
}{
|
|
{
|
|
name: "invalid-config",
|
|
config: EventerConfig{
|
|
AuditDelivery: "invalid",
|
|
},
|
|
logger: hclog.Default(),
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "missing-logger",
|
|
config: testSetup.EventerConfig,
|
|
wantErrIs: ErrInvalidParameter,
|
|
},
|
|
{
|
|
name: "success-with-default-config",
|
|
config: EventerConfig{},
|
|
logger: hclog.Default(),
|
|
want: &Eventer{
|
|
logger: hclog.Default(),
|
|
conf: EventerConfig{
|
|
Sinks: []SinkConfig{
|
|
{
|
|
Name: "default",
|
|
EventTypes: []Type{EveryType},
|
|
Format: JSONSinkFormat,
|
|
SinkType: StdoutSink,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
wantRegistered: []string{
|
|
"json", // fmt for everything
|
|
"stdout", // stdout
|
|
"gated-observation", // stdout
|
|
"gated-audit", // stdout
|
|
},
|
|
wantPipelines: []string{
|
|
"audit", // stdout
|
|
"observation", // stdout
|
|
"error", // stdout
|
|
"system", // stderr
|
|
},
|
|
wantThresholds: map[eventlogger.EventType]int{
|
|
"error": 1,
|
|
},
|
|
},
|
|
{
|
|
name: "testSetup",
|
|
config: testSetup.EventerConfig,
|
|
logger: hclog.Default(),
|
|
want: &Eventer{
|
|
logger: hclog.Default(),
|
|
conf: testSetup.EventerConfig,
|
|
},
|
|
wantRegistered: []string{
|
|
"json", // fmt for everything
|
|
"stdout", // stdout
|
|
"gated-observation", // stdout
|
|
"gated-audit", // stdout
|
|
"tmp-all-events", // every-type-file-sync
|
|
"gated-observation", // every-type-file-sync
|
|
"gated-audit", // every-type-file-sync
|
|
"tmp-errors", // error-file-sink
|
|
},
|
|
wantPipelines: []string{
|
|
"audit", // every-type-file-sync
|
|
"audit", // stdout
|
|
"observation", // every-type-file-sync
|
|
"observation", // stdout
|
|
"error", // every-type-file-sync
|
|
"error", // stdout
|
|
"error", // error-file-sink
|
|
"system", // stderr
|
|
"system", // stderr
|
|
},
|
|
wantThresholds: map[eventlogger.EventType]int{
|
|
"audit": 2,
|
|
"error": 3,
|
|
"observation": 2,
|
|
},
|
|
},
|
|
{
|
|
name: "testSetup-with-all-opts",
|
|
config: testSetupWithOpts.EventerConfig,
|
|
logger: hclog.Default(),
|
|
want: &Eventer{
|
|
logger: hclog.Default(),
|
|
conf: testSetupWithOpts.EventerConfig,
|
|
},
|
|
wantRegistered: []string{
|
|
"json", // fmt for everything
|
|
"stdout", // stdout
|
|
"gated-observation", // stdout
|
|
"gated-audit", // stdout
|
|
"tmp-all-events", // every-type-file-sync
|
|
"gated-observation", // every-type-file-sync
|
|
"gated-audit", // every-type-file-sync
|
|
"tmp-errors", // error-file-sink
|
|
"gated-observation", // observation-file-sink
|
|
"tmp-observation", // observations-file-sink
|
|
"gated-audit", // audit-file-sink
|
|
"tmp-audit", // audit-file-sink
|
|
"tmp-sysevents", // sys-file-sink
|
|
},
|
|
wantPipelines: []string{
|
|
"audit", // every-type-file-sync
|
|
"audit", // stdout
|
|
"observation", // every-type-file-sync
|
|
"observation", // stdout
|
|
"error", // every-type-file-sync
|
|
"error", // stdout
|
|
"error", // error-file-sink
|
|
"audit", // audit-file-sink
|
|
"observation", // observation-file-sink
|
|
"system", // stderr
|
|
"system", // every-type-file-sync
|
|
"system", // sys-file-sink
|
|
},
|
|
wantThresholds: map[eventlogger.EventType]int{
|
|
"audit": 3,
|
|
"error": 3,
|
|
"observation": 3,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
testBroker := &testMockBroker{}
|
|
got, err := NewEventer(tt.logger, tt.config, testWithBroker(testBroker))
|
|
if tt.wantErrIs != nil {
|
|
require.Error(err)
|
|
require.Nil(got)
|
|
assert.ErrorIs(err, tt.wantErrIs)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
require.NotNil(got)
|
|
tt.want.broker = got.broker
|
|
tt.want.flushableNodes = got.flushableNodes
|
|
assert.Equal(tt.want, got)
|
|
|
|
assert.Lenf(testBroker.registeredNodeIds, len(tt.wantRegistered), "got nodes: %q", testBroker.registeredNodeIds)
|
|
for _, want := range tt.wantRegistered {
|
|
found := false
|
|
for _, got := range testBroker.registeredNodeIds {
|
|
if strings.Contains(string(got), want) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.Truef(found, "did not find %s in the registered nodes: %s", want, testBroker.registeredNodeIds)
|
|
}
|
|
assert.Lenf(testBroker.pipelines, len(tt.wantPipelines), "got pipelines: %q", testBroker.pipelines)
|
|
for _, want := range tt.wantPipelines {
|
|
found := false
|
|
for _, got := range testBroker.pipelines {
|
|
if strings.Contains(string(got.EventType), want) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.Truef(found, "did not find %s in the registered pipelines: %s", want, testBroker.pipelines)
|
|
}
|
|
|
|
assert.Equal(tt.wantThresholds, testBroker.successThresholds)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEventer_Reopen(t *testing.T) {
|
|
t.Parallel()
|
|
t.Run("simple", func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
e, err := NewEventer(hclog.Default(), EventerConfig{})
|
|
require.NoError(err)
|
|
|
|
e.broker = nil
|
|
require.NoError(e.Reopen())
|
|
|
|
e.broker = &testMockBroker{}
|
|
require.NoError(e.Reopen())
|
|
assert.True(e.broker.(*testMockBroker).reopened)
|
|
})
|
|
}
|
|
|
|
func TestEventer_FlushNodes(t *testing.T) {
|
|
t.Parallel()
|
|
t.Run("simple", func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
e, err := NewEventer(hclog.Default(), EventerConfig{})
|
|
require.NoError(err)
|
|
|
|
node := &testFlushNode{}
|
|
e.flushableNodes = append(e.flushableNodes, node)
|
|
require.NoError(e.FlushNodes(context.Background()))
|
|
|
|
node.raiseError = true
|
|
require.Error(e.FlushNodes(context.Background()))
|
|
assert.True(node.flushed)
|
|
})
|
|
}
|
|
|
|
type testFlushNode struct {
|
|
flushed bool
|
|
raiseError bool
|
|
}
|
|
|
|
func (t *testFlushNode) FlushAll(_ context.Context) error {
|
|
t.flushed = true
|
|
if t.raiseError {
|
|
return fmt.Errorf("%s: test error: flush-all", ErrInvalidParameter)
|
|
}
|
|
return nil
|
|
}
|