func TestPublisherModes(t *testing.T) {
tests := []struct {
title string
async bool
order []int
}{
{"sync", false, []int{1, 2, 3, 4, 5, 6}},
{"async ordered signal", true, []int{1, 2, 3, 4, 5, 6}},
{"async out of order signal", true, []int{5, 2, 3, 1, 4, 6}},
}
for i, test := range tests {
t.Logf("run publisher test (%v): %v", i, test.title)
wg := sync.WaitGroup{}
pubChan := make(chan []*input.Event, len(test.order)+1)
collector := &collectLogger{&wg, nil}
client := pubtest.NewChanClient(0)
pub := New(test.async, pubChan, collector,
pubtest.PublisherWithClient(client))
pub.Start()
var events [][]*input.Event
for i := range test.order {
tmp := makeEvents(fmt.Sprintf("msg: %v", i), 1)
wg.Add(1)
pubChan <- tmp
events = append(events, tmp)
}
var msgs []pubtest.PublishMessage
for _ = range test.order {
m := <-client.Channel
msgs = append(msgs, m)
}
for _, i := range test.order {
op.SigCompleted(msgs[i-1].Context.Signal)
}
wg.Wait()
pub.Stop()
// validate order
assert.Equal(t, len(events), len(collector.events))
for i := range events {
assert.Equal(t, events[i], collector.events[i])
}
}
}
func TestPublisherModes(t *testing.T) {
tests := []struct {
title string
async bool
order []int
}{
{"sync", false, []int{1, 2, 3, 4, 5, 6}},
{"async ordered signal", true, []int{1, 2, 3, 4, 5, 6}},
{"async out of order signal", true, []int{5, 2, 3, 1, 4, 6}},
}
for i, test := range tests {
t.Logf("run publisher test (%v): %v", i, test.title)
pubChan := make(chan []*input.FileEvent, len(test.order)+1)
regChan := make(chan []*input.FileEvent, len(test.order)+1)
client := pubtest.NewChanClient(0)
pub := newPublisher(test.async, pubChan, regChan, client)
pub.Start()
var events [][]*input.FileEvent
for i := range test.order {
tmp := makeEvents(fmt.Sprintf("msg: %v", i), 1)
pubChan <- tmp
events = append(events, tmp)
}
var msgs []pubtest.PublishMessage
for _ = range test.order {
m := <-client.Channel
msgs = append(msgs, m)
}
for _, i := range test.order {
op.SigCompleted(msgs[i-1].Context.Signal)
}
var regEvents [][]*input.FileEvent
for _ = range test.order {
regEvents = append(regEvents, <-regChan)
}
pub.Stop()
// validate order
for i := range events {
assert.Equal(t, events[i], regEvents[i])
}
}
}
// newPubClientFactory returns a new ChanClient and a function that returns
// the same Client when invoked. This simulates the return value of
// Publisher.Connect.
func newPubClientFactory() (*pubtest.ChanClient, func() publisher.Client) {
client := pubtest.NewChanClient(10)
return client, func() publisher.Client { return client }
}