2020-12-30 16:03:01 +00:00
|
|
|
package audit_test
|
|
|
|
|
|
|
|
import (
|
2021-01-02 16:24:06 +00:00
|
|
|
"crypto/tls"
|
2020-12-30 16:03:01 +00:00
|
|
|
"net"
|
2021-01-02 16:24:06 +00:00
|
|
|
"net/http"
|
2020-12-30 16:03:01 +00:00
|
|
|
"sync"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"gitlab.com/inetmock/inetmock/pkg/audit"
|
|
|
|
"gitlab.com/inetmock/inetmock/pkg/logging"
|
2021-01-02 16:24:06 +00:00
|
|
|
"google.golang.org/protobuf/types/known/anypb"
|
2020-12-30 16:03:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
defaultSink = &testSink{
|
|
|
|
name: "test defaultSink",
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
testEvents = []audit.Event{
|
|
|
|
{
|
|
|
|
Transport: audit.TransportProtocol_TCP,
|
|
|
|
Application: audit.AppProtocol_HTTP,
|
|
|
|
SourceIP: net.ParseIP("127.0.0.1"),
|
|
|
|
DestinationIP: net.ParseIP("127.0.0.1"),
|
|
|
|
SourcePort: 32344,
|
|
|
|
DestinationPort: 80,
|
|
|
|
TLS: &audit.TLSDetails{
|
|
|
|
Version: tls.VersionTLS13,
|
|
|
|
CipherSuite: tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
|
|
|
|
ServerName: "localhost",
|
|
|
|
},
|
|
|
|
ProtocolDetails: mustMarshalToWireformat(audit.HTTPDetails{
|
|
|
|
Method: "GET",
|
|
|
|
Host: "localhost",
|
|
|
|
URI: "http://localhost/asdf",
|
|
|
|
Proto: "HTTP 1.1",
|
|
|
|
Headers: http.Header{
|
|
|
|
"Accept": []string{"application/json"},
|
|
|
|
},
|
|
|
|
}),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Transport: audit.TransportProtocol_TCP,
|
|
|
|
Application: audit.AppProtocol_DNS,
|
|
|
|
SourceIP: net.ParseIP("::1"),
|
|
|
|
DestinationIP: net.ParseIP("::1"),
|
|
|
|
SourcePort: 32344,
|
|
|
|
DestinationPort: 80,
|
|
|
|
},
|
|
|
|
}
|
2020-12-30 16:03:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type testSink struct {
|
|
|
|
name string
|
|
|
|
consumer func(event audit.Event)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *testSink) Name() string {
|
|
|
|
return t.name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *testSink) OnSubscribe(evs <-chan audit.Event) {
|
|
|
|
go func() {
|
|
|
|
for ev := range evs {
|
|
|
|
if t.consumer != nil {
|
|
|
|
t.consumer(ev)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
func wgMockSink(t testing.TB, wg *sync.WaitGroup) audit.Sink {
|
|
|
|
return &testSink{
|
|
|
|
name: "WG mock sink",
|
|
|
|
consumer: func(event audit.Event) {
|
|
|
|
t.Logf("Got event = %v", event)
|
|
|
|
wg.Done()
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-02 16:24:06 +00:00
|
|
|
func mustMarshalToWireformat(d audit.Details) *anypb.Any {
|
|
|
|
any, err := d.MarshalToWireFormat()
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return any
|
|
|
|
}
|
|
|
|
|
2020-12-30 16:03:01 +00:00
|
|
|
func Test_eventStream_RegisterSink(t *testing.T) {
|
|
|
|
type args struct {
|
|
|
|
s audit.Sink
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
type testCase struct {
|
2020-12-30 16:03:01 +00:00
|
|
|
name string
|
|
|
|
args args
|
|
|
|
setup func(e audit.EventStream)
|
|
|
|
wantErr bool
|
2021-01-02 16:24:06 +00:00
|
|
|
}
|
|
|
|
tests := []testCase{
|
2020-12-30 16:03:01 +00:00
|
|
|
{
|
|
|
|
name: "Register test defaultSink",
|
|
|
|
args: args{
|
|
|
|
s: defaultSink,
|
|
|
|
},
|
|
|
|
wantErr: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "Fail due to already registered defaultSink",
|
|
|
|
args: args{
|
|
|
|
s: defaultSink,
|
|
|
|
},
|
|
|
|
setup: func(e audit.EventStream) {
|
|
|
|
_ = e.RegisterSink(defaultSink)
|
|
|
|
},
|
|
|
|
wantErr: true,
|
|
|
|
},
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
scenario := func(tt testCase) func(t *testing.T) {
|
|
|
|
return func(t *testing.T) {
|
2020-12-30 16:03:01 +00:00
|
|
|
var err error
|
|
|
|
var e audit.EventStream
|
|
|
|
if e, err = audit.NewEventStream(logging.CreateTestLogger(t)); err != nil {
|
|
|
|
t.Errorf("NewEventStream() error = %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Cleanup(func() {
|
|
|
|
_ = e.Close()
|
|
|
|
})
|
|
|
|
|
|
|
|
if tt.setup != nil {
|
|
|
|
tt.setup(e)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := e.RegisterSink(tt.args.s); (err != nil) != tt.wantErr {
|
|
|
|
t.Errorf("RegisterSink() error = %v, wantErr %v", err, tt.wantErr)
|
|
|
|
}
|
|
|
|
|
|
|
|
found := false
|
|
|
|
for _, s := range e.Sinks() {
|
|
|
|
if found = s == tt.args.s.Name(); found {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !found {
|
|
|
|
t.Errorf("expected defaultSink name %s not found in registered sinks %v", tt.args.s.Name(), e.Sinks())
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, scenario(tt))
|
2020-12-30 16:03:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func Test_eventStream_Emit(t *testing.T) {
|
|
|
|
type args struct {
|
|
|
|
evs []audit.Event
|
|
|
|
opts []audit.EventStreamOption
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
type testCase struct {
|
2020-12-30 16:03:01 +00:00
|
|
|
name string
|
|
|
|
args args
|
|
|
|
subscribe bool
|
2021-01-02 16:24:06 +00:00
|
|
|
}
|
|
|
|
tests := []testCase{
|
2020-12-30 16:03:01 +00:00
|
|
|
{
|
|
|
|
name: "Expect to get a single event",
|
|
|
|
subscribe: true,
|
|
|
|
args: args{
|
|
|
|
opts: []audit.EventStreamOption{audit.WithBufferSize(10)},
|
2021-01-02 16:24:06 +00:00
|
|
|
evs: testEvents[:1],
|
2020-12-30 16:03:01 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "Expect to get multiple events",
|
|
|
|
subscribe: true,
|
|
|
|
args: args{
|
|
|
|
opts: []audit.EventStreamOption{audit.WithBufferSize(10)},
|
2021-01-02 16:24:06 +00:00
|
|
|
evs: testEvents,
|
2020-12-30 16:03:01 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "Emit without subscribe sink",
|
|
|
|
args: args{
|
|
|
|
opts: []audit.EventStreamOption{audit.WithBufferSize(0)},
|
2021-01-02 16:24:06 +00:00
|
|
|
evs: testEvents[:1],
|
2020-12-30 16:03:01 +00:00
|
|
|
},
|
|
|
|
subscribe: false,
|
|
|
|
},
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
|
|
|
|
scenario := func(tt testCase) func(t *testing.T) {
|
|
|
|
return func(t *testing.T) {
|
2020-12-30 16:03:01 +00:00
|
|
|
var err error
|
|
|
|
var e audit.EventStream
|
|
|
|
if e, err = audit.NewEventStream(logging.CreateTestLogger(t), tt.args.opts...); err != nil {
|
|
|
|
t.Errorf("NewEventStream() error = %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Cleanup(func() {
|
|
|
|
_ = e.Close()
|
|
|
|
})
|
|
|
|
|
2021-01-02 16:24:06 +00:00
|
|
|
emittedWaitGroup := new(sync.WaitGroup)
|
|
|
|
receivedWaitGroup := new(sync.WaitGroup)
|
2020-12-30 16:03:01 +00:00
|
|
|
|
|
|
|
emittedWaitGroup.Add(len(tt.args.evs))
|
|
|
|
|
|
|
|
if tt.subscribe {
|
|
|
|
receivedWaitGroup.Add(len(tt.args.evs))
|
|
|
|
if err := e.RegisterSink(wgMockSink(t, receivedWaitGroup)); err != nil {
|
|
|
|
t.Errorf("RegisterSink() error = %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
go func(evs []audit.Event, wg *sync.WaitGroup) {
|
|
|
|
for _, ev := range evs {
|
|
|
|
e.Emit(ev)
|
|
|
|
wg.Done()
|
|
|
|
}
|
|
|
|
}(tt.args.evs, emittedWaitGroup)
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-waitGroupDone(emittedWaitGroup):
|
|
|
|
case <-time.After(100 * time.Millisecond):
|
|
|
|
t.Errorf("not all events emitted in time")
|
|
|
|
}
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-waitGroupDone(receivedWaitGroup):
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
t.Errorf("did not get all expected events in time")
|
|
|
|
}
|
2021-01-02 16:24:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, scenario(tt))
|
2020-12-30 16:03:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func waitGroupDone(wg *sync.WaitGroup) <-chan struct{} {
|
|
|
|
done := make(chan struct{})
|
|
|
|
|
|
|
|
go func(wg *sync.WaitGroup) {
|
|
|
|
wg.Wait()
|
|
|
|
close(done)
|
|
|
|
}(wg)
|
|
|
|
|
|
|
|
return done
|
|
|
|
}
|