325 lines
10 KiB
Go
325 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"sync"
|
|
"testing"
|
|
|
|
"git.sr.ht/~michalr/go-satel"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestSatelEventTypeFiltering(t *testing.T) {
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{{satel.ArmedPartition}, {satel.PartitionFireAlarm}}, []int{}) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.DoorOpened, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.PartitionAlarm, 3, true)
|
|
testEvents <- makeTestSatelEvent(satel.PartitionFireAlarm, 4, true)
|
|
testEvents <- makeTestSatelEvent(satel.TroublePart1, 5, true)
|
|
testEvents <- makeTestSatelEvent(satel.ZoneTamper, 6, true)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, 2)
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.PartitionFireAlarm, 4, true))
|
|
}
|
|
|
|
func TestSatelEventTypeFiltering_NoAllowedEventTypesMeansAllAreAllowed(t *testing.T) {
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{}) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
for index, ct := range SUPPORTED_CHANGE_TYPES {
|
|
testEvents <- makeTestSatelEvent(ct, index, true)
|
|
}
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, len(SUPPORTED_CHANGE_TYPES))
|
|
for index, ct := range SUPPORTED_CHANGE_TYPES {
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(ct, index, true))
|
|
}
|
|
}
|
|
|
|
func TestSatelIndexFiltering(t *testing.T) {
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{1, 3}) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.DoorOpened, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.PartitionAlarm, 3, true)
|
|
testEvents <- makeTestSatelEvent(satel.PartitionFireAlarm, 4, true)
|
|
testEvents <- makeTestSatelEvent(satel.TroublePart1, 5, true)
|
|
testEvents <- makeTestSatelEvent(satel.ZoneTamper, 6, true)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, 2)
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.PartitionAlarm, 3, true))
|
|
}
|
|
|
|
func TestSatelIndexFiltering_NoAllowedEventTypesMeansAllAreAllowed(t *testing.T) {
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
myReasonableMaxIndex := 100 // I wanted to use math.MaxInt at first, but it's kind of a waste of time here
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{}) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
for i := 0; i < myReasonableMaxIndex; i++ {
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, i, true)
|
|
}
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, myReasonableMaxIndex)
|
|
for i := 0; i < myReasonableMaxIndex; i++ {
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, i, true))
|
|
}
|
|
}
|
|
|
|
func TestSatelLastSeenFiltering(t *testing.T) {
|
|
f, err := os.CreateTemp("", "TestSatelLastSeenFiltering")
|
|
assert.NoError(t, err)
|
|
tempFileName := f.Name()
|
|
assert.NoError(t, f.Close())
|
|
defer os.Remove(f.Name())
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
fakeLog := log.New(io.Discard, "", log.Ltime)
|
|
ds := MakeDataStore(fakeLog, tempFileName)
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByLastSeen(testEvents, &wg, &ds, fakeLog) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, 3)
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 2, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, false))
|
|
}
|
|
|
|
func TestSatelLastSeenFilteringWithPersistence(t *testing.T) {
|
|
f, err := os.CreateTemp("", "TestSatelLastSeenFilteringWithPersistence")
|
|
assert.NoError(t, err)
|
|
tempFileName := f.Name()
|
|
assert.NoError(t, f.Close())
|
|
defer os.Remove(f.Name())
|
|
testEvents := make(chan satel.Event)
|
|
receivedEvents := make([]satel.Event, 0)
|
|
wg := sync.WaitGroup{}
|
|
fakeLog := log.New(io.Discard, "", log.Ltime)
|
|
ds := MakeDataStore(fakeLog, tempFileName)
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByLastSeen(testEvents, &wg, &ds, fakeLog) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, 3)
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 2, true))
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, false))
|
|
|
|
testEvents = make(chan satel.Event)
|
|
receivedEvents = make([]satel.Event, 0)
|
|
ds = MakeDataStore(fakeLog, tempFileName)
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range FilterByLastSeen(testEvents, &wg, &ds, fakeLog) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
receivedEvents = make([]satel.Event, 0)
|
|
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, false)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 1, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
testEvents <- makeTestSatelEvent(satel.ArmedPartition, 2, true)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Len(t, receivedEvents, 1)
|
|
assert.Contains(t, receivedEvents, makeTestSatelEvent(satel.ArmedPartition, 1, true))
|
|
}
|
|
|
|
type MockSleeper struct {
|
|
ch *chan<- interface{}
|
|
callCount int
|
|
}
|
|
|
|
func (self *MockSleeper) Sleep(ch chan<- interface{}) {
|
|
if self.ch == nil {
|
|
self.ch = &ch
|
|
}
|
|
self.callCount += 1
|
|
}
|
|
|
|
func TestThrottle(t *testing.T) {
|
|
testEvents := make(chan GenericMessage)
|
|
receivedEvents := make([]GenericMessage, 0)
|
|
wg := sync.WaitGroup{}
|
|
fakeLog := log.New(io.Discard, "", log.Ltime)
|
|
mockSleeper := MockSleeper{nil, 0}
|
|
|
|
var (
|
|
tplMessageTest1 = satel.BasicEventElement{Type: satel.ArmedPartition, Index: 1, Value: true}
|
|
tplMessageTest2 = satel.BasicEventElement{Type: satel.ZoneViolation, Index: 2, Value: true}
|
|
tplMessageTest3 = satel.BasicEventElement{Type: satel.ArmedPartition, Index: 1, Value: false}
|
|
tplMessageTest4 = satel.BasicEventElement{Type: satel.ZoneViolation, Index: 2, Value: false}
|
|
)
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range Throttle(testEvents, &wg, &mockSleeper, fakeLog) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest1}}
|
|
testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest2}}
|
|
testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest3}}
|
|
*mockSleeper.ch <- nil
|
|
|
|
testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest4}}
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Equal(t, 2, mockSleeper.callCount)
|
|
assert.Len(t, receivedEvents, 2)
|
|
assert.Contains(t, receivedEvents[0].Messages, tplMessageTest2)
|
|
assert.Contains(t, receivedEvents[0].Messages, tplMessageTest3)
|
|
assert.Len(t, receivedEvents[0].Messages, 2)
|
|
|
|
assert.Contains(t, receivedEvents[1].Messages, tplMessageTest4)
|
|
assert.Len(t, receivedEvents[1].Messages, 1)
|
|
}
|
|
|
|
func makeMassiveEvent(element satel.BasicEventElement, numElements int) GenericMessage {
|
|
retval := GenericMessage{make([]satel.BasicEventElement, 0)}
|
|
|
|
for i := 0; i < numElements; i++ {
|
|
retval.Messages = append(retval.Messages, element)
|
|
}
|
|
|
|
return retval
|
|
}
|
|
|
|
func TestThrottle_ManyMessagesInOneEvent(t *testing.T) {
|
|
testEvents := make(chan GenericMessage)
|
|
receivedEvents := make([]GenericMessage, 0)
|
|
wg := sync.WaitGroup{}
|
|
fakeLog := log.New(io.Discard, "", log.Ltime)
|
|
mockSleeper := MockSleeper{nil, 0}
|
|
|
|
var (
|
|
tplMessageTest1 = satel.BasicEventElement{Type: satel.ArmedPartition, Index: 1, Value: true}
|
|
tplMessageTest2 = satel.BasicEventElement{Type: satel.ZoneViolation, Index: 2, Value: true}
|
|
tplMessageTest3 = satel.BasicEventElement{Type: satel.ArmedPartition, Index: 1, Value: false}
|
|
tplMessageTest4 = satel.BasicEventElement{Type: satel.ZoneViolation, Index: 2, Value: false}
|
|
)
|
|
|
|
go func() {
|
|
wg.Add(1)
|
|
for e := range Throttle(testEvents, &wg, &mockSleeper, fakeLog) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
|
|
testEvents <- makeMassiveEvent(tplMessageTest1, 100)
|
|
testEvents <- makeMassiveEvent(tplMessageTest2, 100)
|
|
testEvents <- makeMassiveEvent(tplMessageTest3, 100)
|
|
*mockSleeper.ch <- nil
|
|
|
|
testEvents <- makeMassiveEvent(tplMessageTest4, 100)
|
|
|
|
close(testEvents)
|
|
wg.Wait()
|
|
|
|
assert.Equal(t, 2, mockSleeper.callCount)
|
|
assert.Len(t, receivedEvents, 2)
|
|
assert.Contains(t, receivedEvents[0].Messages, tplMessageTest2)
|
|
assert.Contains(t, receivedEvents[0].Messages, tplMessageTest3)
|
|
assert.Len(t, receivedEvents[0].Messages, 2)
|
|
|
|
assert.Contains(t, receivedEvents[1].Messages, tplMessageTest4)
|
|
assert.Len(t, receivedEvents[1].Messages, 1)
|
|
}
|