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 } } } }