func (s *StreamSuite) TestPack(c *C) {
loghub.Start()
log.Println("testing pack")
b, ch := newBlock("testing pack", "pack")
go blocks.BlockRoutine(b)
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{
Route: "out",
Channel: outChan,
}
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
ruleMsg := map[string]interface{}{"Path": ".a", "EmitAfter": "4s"}
rule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- rule
/*
m := map[string]string{"b": "test"}
arr := []interface{}{m}
inMsg := map[string]interface{}{"a": arr}
ch.InChan <- &blocks.Msg{Msg: inMsg, Route: "in"}
*/
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case <-outChan:
}
}
}
func (s *StreamSuite) TestSet(c *C) {
loghub.Start()
log.Println("testing set")
b, ch := newBlock("testing set", "set")
go blocks.BlockRoutine(b)
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{
Route: "out",
Channel: outChan,
}
ruleMsg := map[string]interface{}{"Path": ".a"}
rule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- rule
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case <-outChan:
}
}
}
func main() {
flag.Parse()
if *version {
log.Println("Streamtools version:", util.VERSION)
os.Exit(0)
}
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
library.Start()
loghub.Start()
s := server.NewServer()
for _, file := range flag.Args() {
s.ImportFile(file)
}
s.Id = "SERVER"
s.Port = *port
s.Domain = *domain
s.Run()
}
func (s *StreamSuite) TestPoisson(c *C) {
loghub.Start()
log.Println("testing Poisson")
b, ch := newBlock("testingPoisson", "poisson")
go blocks.BlockRoutine(b)
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{
Route: "out",
Channel: outChan,
}
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case <-outChan:
}
}
}
func (s *DeDupeSuite) TestDeDupe(c *C) {
loghub.Start()
log.Println("testing dedupe")
b, ch := test_utils.NewBlock("testing dedupe", "dedupe")
emittedValues := make(map[string]bool)
go blocks.BlockRoutine(b)
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{
Route: "out",
Channel: outChan,
}
ruleMsg := map[string]interface{}{"Path": ".a"}
rule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- rule
var sampleInput = map[string]interface{}{
"a": "foobar",
}
time.AfterFunc(time.Duration(2)*time.Second, func() {
postData := &blocks.Msg{Msg: sampleInput, Route: "in"}
ch.InChan <- postData
})
time.AfterFunc(time.Duration(1)*time.Second, func() {
postData := &blocks.Msg{Msg: sampleInput, Route: "in"}
ch.InChan <- postData
})
time.AfterFunc(time.Duration(1)*time.Second, func() {
postData := &blocks.Msg{Msg: map[string]interface{}{"a": "baz"}, Route: "in"}
ch.InChan <- postData
})
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case messageI := <-outChan:
message := messageI.Msg.(map[string]interface{})
value := message["a"].(string)
_, ok := emittedValues[value]
if ok {
c.Errorf("block emitted a dupe message", value)
} else {
emittedValues[value] = true
}
}
}
}
func (s *SyncSuite) TestSync(c *C) {
loghub.Start()
log.Println("testing Sync")
b, ch := test_utils.NewBlock("testingSync", "sync")
go blocks.BlockRoutine(b)
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
err := <-ch.ErrChan
if err != nil {
c.Errorf(err.Error())
}
}
func main() {
flag.Parse()
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
library.Start()
loghub.Start()
s := server.NewServer()
s.Id = "SERVER"
s.Port = *port
s.Domain = *domain
s.Run()
}
func (s *RedisSuite) TestRedisSMEMBERS(c *C) {
loghub.Start()
log.Println("testing Redis: SMEMBERS")
b, ch := test_utils.NewBlock("testingRedisSMEM", "redis")
go blocks.BlockRoutine(b)
m := []string{"'foobar'"}
ruleMsg := map[string]interface{}{"Server": "localhost:6379", "Password": "", "Command": "SMEMBERS", "Arguments": m}
toRule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- toRule
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{Route: "1", Channel: outChan}
ch.InChan <- &blocks.Msg{Msg: map[string]interface{}{"tick": "123"}, Route: "in"}
queryOutChan := make(blocks.MsgChan)
ch.QueryChan <- &blocks.QueryMsg{MsgChan: queryOutChan, Route: "rule"}
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case messageI := <-queryOutChan:
if !reflect.DeepEqual(messageI, ruleMsg) {
log.Println("Rule mismatch:", messageI, ruleMsg)
c.Fail()
}
case messageI := <-outChan:
message := messageI.Msg.(map[string]interface{})
expectedValue := []interface{}{"baz"}
c.Assert(message["response"], DeepEquals, expectedValue)
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
}
}
}
func (s *ToFileSuite) TestToFile(c *C) {
loghub.Start()
log.Println("testing toFile")
b, ch := test_utils.NewBlock("testingToFile", "tofile")
go blocks.BlockRoutine(b)
ruleMsg := map[string]interface{}{"Filename": "foobar.log"}
toRule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- toRule
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{Route: "1", Channel: outChan}
queryOutChan := make(blocks.MsgChan)
ch.QueryChan <- &blocks.QueryMsg{MsgChan: queryOutChan, Route: "rule"}
time.AfterFunc(time.Duration(5)*time.Second, func() {
err := os.Remove("foobar.log")
if err != nil {
c.Errorf(err.Error())
}
ch.QuitChan <- true
})
for {
select {
case messageI := <-queryOutChan:
if !reflect.DeepEqual(messageI, ruleMsg) {
c.Fail()
}
case message := <-outChan:
log.Println(message)
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
}
}
}
func (s *TickerSuite) TestTicker(c *C) {
loghub.Start()
log.Println("testing Ticker")
b, ch := test_utils.NewBlock("testingTicker", "ticker")
go blocks.BlockRoutine(b)
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{Route: "1", Channel: outChan}
queryOutChan := make(blocks.MsgChan)
ch.QueryChan <- &blocks.QueryMsg{MsgChan: queryOutChan, Route: "rule"}
ruleMsg := map[string]interface{}{"Interval": "1s"}
toRule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- toRule
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case messageI := <-queryOutChan:
if !reflect.DeepEqual(messageI, ruleMsg) {
log.Println("Rule mismatch:", messageI, ruleMsg)
c.Fail()
}
case messageI := <-outChan:
message := messageI.Msg.(map[string]interface{})
c.Assert(message["tick"], NotNil)
}
}
}
// this is run once before the entire test SUITE
func (s *StreamSuite) SetUpSuite(c *C) {
loghub.Start()
}
func (s *CacheSuite) TestCache(c *C) {
loghub.Start()
log.Println("testing cache")
b, ch := test_utils.NewBlock("testing cache", "cache")
go blocks.BlockRoutine(b)
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{
Route: "out",
Channel: outChan,
}
ruleMsg := map[string]interface{}{"KeyPath": ".name", "ValuePath": ".count", "TimeToLive": "1m"}
rule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- rule
// Add some data to the cache
time.AfterFunc(time.Duration(1)*time.Second, func() {
ch.InChan <- &blocks.Msg{Msg: map[string]interface{}{"count": "100", "name": "The New York Times"}, Route: "in"}
ch.InChan <- &blocks.Msg{Msg: map[string]interface{}{"count": "4", "name": "The New York Times"}, Route: "in"}
ch.InChan <- &blocks.Msg{Msg: map[string]interface{}{"count": "50", "name": "Hacks/Hackers"}, Route: "in"}
})
// Query for keys
keysChan := make(blocks.MsgChan)
time.AfterFunc(time.Duration(2)*time.Second, func() {
ch.QueryChan <- &blocks.QueryMsg{MsgChan: keysChan, Route: "keys"}
})
// And values
valuesChan := make(blocks.MsgChan)
time.AfterFunc(time.Duration(2)*time.Second, func() {
ch.QueryChan <- &blocks.QueryMsg{MsgChan: valuesChan, Route: "values"}
})
// And the entire cache contents
dumpChan := make(blocks.MsgChan)
time.AfterFunc(time.Duration(2)*time.Second, func() {
ch.QueryChan <- &blocks.QueryMsg{MsgChan: dumpChan, Route: "dump"}
})
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
case messageI := <-keysChan:
message := messageI.(map[string]interface{})
keys := message["keys"].([]string)
c.Assert(keys, DeepEquals, []string{"The New York Times", "Hacks/Hackers"})
case messageI := <-valuesChan:
message := messageI.(map[string]interface{})
values := message["values"].([]interface{})
c.Assert(values, HasLen, 2)
case messageI := <-dumpChan:
message := messageI.(map[string]interface{})
c.Assert(message["dump"], HasLen, 2)
case messageI := <-outChan:
message := messageI.Msg.(map[string]interface{})
log.Println(message)
}
}
}
func (s *FromSQSSuite) TestFromSQS(c *C) {
loghub.Start()
log.Println("testing FromSQS")
sampleResponse := string(`
<CreateQueueResponse
xmlns="http://sqs.us-east-1.amazonaws.com/doc/2012-11-05/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:type="CreateQueueResponse">
<CreateQueueResult>
<QueueUrl>
http://sqs.us-east-1.amazonaws.com/770098461991/queue2
</QueueUrl>
</CreateQueueResult>
<ResponseMetadata>
<RequestId>cb919c0a-9bce-4afe-9b48-9bdf2412bb67</RequestId>
</ResponseMetadata>
</CreateQueueResponse>
`)
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, sampleResponse)
}))
defer ts.Close()
b, ch := test_utils.NewBlock("testingFromSQS", "fromsqs")
go blocks.BlockRoutine(b)
ruleMsg := map[string]interface{}{"QueueName": "queue2", "AccessKey": "123access", "AccessSecret": "123secret", "MaxNumberOfMessages": "10"}
toRule := &blocks.Msg{Msg: ruleMsg, Route: "rule"}
ch.InChan <- toRule
outChan := make(chan *blocks.Msg)
ch.AddChan <- &blocks.AddChanMsg{Route: "1", Channel: outChan}
queryOutChan := make(blocks.MsgChan)
ch.QueryChan <- &blocks.QueryMsg{MsgChan: queryOutChan, Route: "rule"}
time.AfterFunc(time.Duration(5)*time.Second, func() {
ch.QuitChan <- true
})
for {
select {
case messageI := <-queryOutChan:
if !reflect.DeepEqual(messageI, ruleMsg) {
log.Println("Rule mismatch:", messageI, ruleMsg)
c.Fail()
}
case message := <-outChan:
log.Println(message)
case err := <-ch.ErrChan:
if err != nil {
c.Errorf(err.Error())
} else {
return
}
}
}
}
