func TestThatItSendsAllDataToAllSinks(t *testing.T) { client1ReceivedChan := make(chan []byte) client2ReceivedChan := make(chan []byte) testhelpers.AddWSSink(t, client1ReceivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) testhelpers.AddWSSink(t, client2ReceivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) WaitForWebsocketRegistration() expectedMessageString := "Some Data" expectedMarshalledProtoBuffer := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") dataReadChannel <- expectedMarshalledProtoBuffer select { case <-time.After(200 * time.Millisecond): t.Errorf("Did not get message from client 1.") case message := <-client1ReceivedChan: testhelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } select { case <-time.After(200 * time.Millisecond): t.Errorf("Did not get message from client 2.") case message := <-client2ReceivedChan: testhelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } }
func TestThatItSendsAllDataToAllSinks(t *testing.T) { client1ReceivedChan := make(chan []byte) client2ReceivedChan := make(chan []byte) _, stopKeepAlive1, _ := testhelpers.AddWSSink(t, client1ReceivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp") _, stopKeepAlive2, _ := testhelpers.AddWSSink(t, client2ReceivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp") WaitForWebsocketRegistration() expectedMessageString := "Some Data" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp", SECRET) dataReadChannel <- logEnvelope select { case <-time.After(200 * time.Millisecond): t.Errorf("Did not get message from client 1.") case message := <-client1ReceivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } select { case <-time.After(200 * time.Millisecond): t.Errorf("Did not get message from client 2.") case message := <-client2ReceivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } stopKeepAlive1 <- true WaitForWebsocketRegistration() stopKeepAlive2 <- true WaitForWebsocketRegistration() }
func TestQueryStringCombinationsThatDropSinkButContinueToWork(t *testing.T) { receivedChan := make(chan []byte, 2) _, _, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) assert.Equal(t, true, <-droppedChannel) TestThatItSends(t) }
func TestItDumpsAllMessagesForAnAppUser(t *testing.T) { expectedMessageString := "Some data" logMessage := messagetesthelpers.NewLogMessage(expectedMessageString, "myOtherApp") envelope := messagetesthelpers.MarshalledLogEnvelope(t, logMessage, SECRET) dataReadChannel <- envelope dataReadChannel <- envelope time.Sleep(100 * time.Millisecond) receivedChan := make(chan []byte, 2) _, stopKeepAlive, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, RECENT_LOGS_PATH+"?app=myOtherApp") logMessages := dumpAllMessages(receivedChan) assert.Equal(t, len(logMessages), 2) messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, logMessages[len(logMessages)-1]) select { case <-droppedChannel: // we should have been dropped case <-time.After(10 * time.Millisecond): t.Error("we should have been dropped") } stopKeepAlive <- true }
func TestThatItSendsLogsToProperAppSink(t *testing.T) { receivedChan := make(chan []byte) otherLogMessage := messagetesthelpers.NewLogMessage("Some other message", "otherApp") otherLogEnvelope := messagetesthelpers.MarshalledLogEnvelope(t, otherLogMessage, SECRET) expectedMessageString := "My important message" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp02", SECRET) _, stopKeepAlive, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp02") WaitForWebsocketRegistration() dataReadChannel <- otherLogEnvelope dataReadChannel <- logEnvelope select { case <-time.After(1 * time.Second): t.Errorf("Did not get message from app sink.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } stopKeepAlive <- true WaitForWebsocketRegistration() }
func TestThatItSends(t *testing.T) { receivedChan := make(chan []byte, 2) expectedMessageString := "Some data" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myApp01") otherMessageString := "Some more stuff" otherMessage := messagetesthelpers.NewMessage(t, otherMessageString, "myApp01") _, dontKeepAliveChan, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, "/tail/?app=myApp01") WaitForWebsocketRegistration() dataReadChannel <- message dataReadChannel <- otherMessage select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 1.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 2.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, otherMessageString, message) } dontKeepAliveChan <- true }
func TestThatItDoesNotRegisterADrainIfItsURLIsBlacklisted(t *testing.T) { receivedChan := make(chan []byte, 2) testhelpers.AddWSSink(t, receivedChan, BLACKLIST_SERVER_PORT, TAIL_PATH+"?app=myApp01") WaitForWebsocketRegistration() clientReceivedChan := make(chan []byte) blackListedSyslogDrain, err := NewFakeService(clientReceivedChan, "127.0.0.1:34570") defer blackListedSyslogDrain.Stop() assert.NoError(t, err) go blackListedSyslogDrain.Serve() <-blackListedSyslogDrain.ReadyChan logEnvelope1 := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, "Some Data", "myApp01", SECRET, "syslog://127.0.0.1:34570") blackListDataReadChannel <- logEnvelope1 assertMessageNotOnChannel(t, 1000, clientReceivedChan, "Should not have received message on blacklisted Syslog drain") select { case <-time.After(1 * time.Second): t.Errorf("Did not get the real message.") case <-receivedChan: } select { case <-time.After(1 * time.Second): t.Errorf("Did not get the error message about the blacklisted syslog drain.") case receivedMessage := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, "MessageRouter: Syslog drain url is blacklisted: syslog://127.0.0.1:34570", receivedMessage) } }
func TestThatItDumpsLogsBeforeTailing(t *testing.T) { receivedChan := make(chan []byte) expectedMessageString := "My important message" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp06", SECRET) dataReadChannel <- logEnvelope _, stopKeepAlive, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp06") WaitForWebsocketRegistration() select { case <-time.After(1 * time.Second): t.Errorf("Did not get message from app sink.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } expectedMessageString2 := "My Other important message" logEnvelope = messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString2, "myApp06", SECRET) dataReadChannel <- logEnvelope select { case <-time.After(1 * time.Second): t.Errorf("Did not get message from app sink.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString2, message) } stopKeepAlive <- true WaitForWebsocketRegistration() }
func TestThatItSends(t *testing.T) { receivedChan := make(chan []byte, 2) expectedMessageString := "Some data" expectedMessage := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") otherMessageString := "Some more stuff" otherMessage := testhelpers.MarshalledLogMessage(t, otherMessageString, "myApp") testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) WaitForWebsocketRegistration() dataReadChannel <- expectedMessage dataReadChannel <- otherMessage select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 1.") case message := <-receivedChan: testhelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 2.") case message := <-receivedChan: testhelpers.AssertProtoBufferMessageEquals(t, otherMessageString, message) } }
func TestDropUnmarshallableMessage(t *testing.T) { receivedChan := make(chan []byte) sink, stopKeepAlive, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp03") WaitForWebsocketRegistration() dataReadChannel <- make([]byte, 10) time.Sleep(1 * time.Millisecond) select { case msg1, ok := <-receivedChan: if ok { t.Errorf("We should not have received a message, but got: %v", msg1) } default: //no communication. That's good! } sink.Close() expectedMessageString := "My important message" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp03", SECRET) dataReadChannel <- logEnvelope stopKeepAlive <- true WaitForWebsocketRegistration() }
func TestAuthTokenCombinationsThatDropSinkButContinueToWork(t *testing.T) { for _, test := range authTokenFailingCombinationTests { receivedChan := make(chan []byte, 2) _, _, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", test.authToken) assert.Equal(t, true, <-droppedChannel) TestThatItSends(t) } }
func TestDontDropSinkThatWorks(t *testing.T) { receivedChan := make(chan []byte, 2) _, _, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) select { case <-time.After(200 * time.Millisecond): case <-droppedChannel: t.Errorf("Channel drop, but shouldn't have.") } TestThatItSends(t) }
func TestItDoesntHangWhenThereAreNoMessages(t *testing.T) { receivedChan := make(chan []byte, 1) testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, RECENT_LOGS_PATH+"?app=myOtherApp") doneChan := make(chan bool) go func() { dumpAllMessages(receivedChan) close(doneChan) }() select { case <-doneChan: break case <-time.After(10 * time.Millisecond): t.Error("Should have returned by now") } }
func TestEndtoEndEnvelopeToMessage(t *testing.T) { receivedChan := make(chan []byte) ws, _, _ := testhelpers.AddWSSink(t, receivedChan, "8083", "/tail/?app=myApp") defer ws.Close() time.Sleep(50 * time.Millisecond) connection, err := net.Dial("udp", "localhost:3456") expectedMessageString := "Some Data" unmarshalledLogMessage := messagetesthelpers.NewLogMessage(expectedMessageString, "myApp") expectedMessage := messagetesthelpers.MarshalledLogEnvelope(t, unmarshalledLogMessage, "secret") _, err = connection.Write(expectedMessage) assert.NoError(t, err) messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, <-receivedChan) }
func TestKeepAlive(t *testing.T) { receivedChan := make(chan []byte, 10) _, killKeepAliveChan, connectionDroppedChannel := testhelpers.AddWSSink(t, receivedChan, FAST_TIMEOUT_SERVER_PORT, "/tail/?app=myApp05") WaitForWebsocketRegistration() go func() { for { expectedMessageString := "My important message" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myApp05") dataReadChannel <- message time.Sleep(2 * time.Millisecond) } }() time.Sleep(10 * time.Millisecond) //wait a little bit to make sure some messages are sent killKeepAliveChan <- true go func() { for { select { case _, ok := <-receivedChan: if !ok { // channel closed good! break } case <-time.After(10 * time.Millisecond): //no communication. That's good! break } } }() select { case fu := <-connectionDroppedChannel: assert.True(t, fu, "We should have been dropped since we stopped the keepalive") case <-time.After(1 * time.Second): t.Fatal("Should have read from connnectionDropppedChannel by now") } }
func TestEndtoEndMessageShouldNotWork(t *testing.T) { receivedChan := make(chan []byte) ws, _, _ := testhelpers.AddWSSink(t, receivedChan, "8083", "/tail/?app=myApp") defer ws.Close() time.Sleep(50 * time.Millisecond) connection, err := net.Dial("udp", "localhost:3456") expectedMessageString := "Some Data" expectedMessage := messagetesthelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") _, err = connection.Write(expectedMessage) assert.NoError(t, err) select { case _ = <-receivedChan: t.Error("Message should have been dropped") case <-time.After(2 * time.Second): //success } }
func TestDropUnmarshallableMessage(t *testing.T) { receivedChan := make(chan []byte) sink, _, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) WaitForWebsocketRegistration() dataReadChannel <- make([]byte, 10) time.Sleep(1 * time.Millisecond) select { case msg1 := <-receivedChan: t.Errorf("We should not have received a message, but got: %v", msg1) default: //no communication. That's good! } sink.Close() expectedMessageString := "My important message" mySpaceMarshalledMessage := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") dataReadChannel <- mySpaceMarshalledMessage }
func TestKeepAlive(t *testing.T) { receivedChan := make(chan []byte) _, killKeepAliveChan, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) WaitForWebsocketRegistration() killKeepAliveChan <- true time.Sleep(60 * time.Millisecond) //wait a little bit to make sure the keep-alive has successfully been stopped expectedMessageString := "My important message" myAppsMarshalledMessage := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") dataReadChannel <- myAppsMarshalledMessage time.Sleep(10 * time.Millisecond) //wait a little bit to give a potential message time to arrive select { case msg1 := <-receivedChan: t.Errorf("We should not have received a message, but got: %v", msg1) default: //no communication. That's good! } }
func TestEndtoEndMessage(t *testing.T) { logger := gosteno.NewLogger("TestLogger") listener := agentlistener.NewAgentListener("localhost:3456", logger) dataChannel := listener.Start() sinkServer := sinkserver.NewSinkServer(messagestore.NewMessageStore(10), logger, testhelpers.SuccessfulAuthorizer, 30*time.Second) go sinkServer.Start(dataChannel, "localhost:8081") time.Sleep(1 * time.Millisecond) receivedChan := make(chan []byte) ws, _, _ := testhelpers.AddWSSink(t, receivedChan, "8081", "/tail/?app=myApp", testhelpers.VALID_SPACE_AUTHENTICATION_TOKEN) defer ws.Close() time.Sleep(50 * time.Millisecond) connection, err := net.Dial("udp", "localhost:3456") expectedMessageString := "Some Data" expectedMessage := testhelpers.MarshalledLogMessage(t, expectedMessageString, "myApp") _, err = connection.Write(expectedMessage) assert.NoError(t, err) testhelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, <-receivedChan) }
func TestThatItDoesNotDumpLogsBeforeTailing(t *testing.T) { receivedChan := make(chan []byte) expectedMessageString := "My important message" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myApp06") dataReadChannel <- message _, stopKeepAlive, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, "/tail/?app=myApp06") WaitForWebsocketRegistration() select { case <-time.After(1 * time.Second): break case _, ok := <-receivedChan: if ok { t.Errorf("Recieved unexpected message from app sink") } } stopKeepAlive <- true WaitForWebsocketRegistration() }
func TestKeepAlive(t *testing.T) { receivedChan := make(chan []byte) _, killKeepAliveChan, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp05") WaitForWebsocketRegistration() killKeepAliveChan <- true time.Sleep(60 * time.Millisecond) //wait a little bit to make sure the keep-alive has successfully been stopped expectedMessageString := "My important message" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp05", SECRET) dataReadChannel <- logEnvelope select { case msg1, ok := <-receivedChan: if ok { t.Errorf("We should not have received a message, but got: %v", msg1) } case <-time.After(10 * time.Millisecond): //no communication. That's good! } }
func TestKeepAlive(t *testing.T) { receivedChan := make(chan []byte, 10) _, killKeepAliveChan, connectionDroppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myApp05") WaitForWebsocketRegistration() go func() { for { expectedMessageString := "My important message" logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp05", SECRET) dataReadChannel <- logEnvelope time.Sleep(2 * time.Millisecond) } }() time.Sleep(10 * time.Millisecond) //wait a little bit to make sure some messages are sent killKeepAliveChan <- true go func() { for { select { case _, ok := <-receivedChan: if !ok { // channel closed good! break } case <-time.After(10 * time.Millisecond): //no communication. That's good! break } } }() assert.True(t, <-connectionDroppedChannel, "We should have been dropped since we stopped the keepalive") }
func TestDontDropSinkThatWorks(t *testing.T) { receivedChan := make(chan []byte, 2) _, stopKeepAlive, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, "/tail/?app=myApp04") select { case <-time.After(200 * time.Millisecond): case <-droppedChannel: t.Errorf("Channel drop, but shouldn't have.") } expectedMessageString := "Some data" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myApp04") dataReadChannel <- message select { case <-time.After(1 * time.Second): t.Errorf("Did not get message.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } stopKeepAlive <- true WaitForWebsocketRegistration() }
func TestItDumpsAllMessagesForAnAppUser(t *testing.T) { expectedMessageString := "Some data" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myOtherApp") dataReadChannel <- message dataReadChannel <- message receivedChan := make(chan []byte, 2) _, stopKeepAlive, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, "/dump/?app=myOtherApp") select { case <-droppedChannel: // we should have been dropped case <-time.After(10 * time.Millisecond): t.Error("we should have been dropped") } logMessages := dumpAllMessages(receivedChan) assert.Equal(t, len(logMessages), 2) messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, logMessages[len(logMessages)-1]) stopKeepAlive <- true }
func TestQueryStringCombinationsThatDropSinkButContinueToWork(t *testing.T) { receivedChan := make(chan []byte, 2) _, _, droppedChannel := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?") assert.Equal(t, true, <-droppedChannel) }
func TestMetrics(t *testing.T) { oldDumpSinksCounter := TestMessageRouter.Emit().Metrics[0].Value.(int) oldSyslogSinksCounter := TestMessageRouter.Emit().Metrics[1].Value.(int) oldWebsocketSinksCounter := TestMessageRouter.Emit().Metrics[2].Value.(int) clientReceivedChan := make(chan []byte) fakeSyslogDrain, err := NewFakeService(clientReceivedChan, "127.0.0.1:32564") assert.NoError(t, err) go fakeSyslogDrain.Serve() <-fakeSyslogDrain.ReadyChan assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Name, "numberOfDumpSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Value, oldDumpSinksCounter) assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Name, "numberOfSyslogSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Value, oldSyslogSinksCounter) assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Name, "numberOfWebsocketSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Value, oldWebsocketSinksCounter) logEnvelope := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, "expectedMessageString", "myMetricsApp", SECRET, "syslog://localhost:32564") dataReadChannel <- logEnvelope select { case <-time.After(1000 * time.Millisecond): t.Errorf("Did not get message 1") case <-clientReceivedChan: } assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Name, "numberOfDumpSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Value, oldDumpSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Name, "numberOfSyslogSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Value, oldSyslogSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Name, "numberOfWebsocketSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Value, oldWebsocketSinksCounter) dataReadChannel <- logEnvelope select { case <-time.After(1000 * time.Millisecond): t.Errorf("Did not get message 1") case <-clientReceivedChan: } assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Name, "numberOfDumpSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Value, oldDumpSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Name, "numberOfSyslogSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Value, oldSyslogSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Name, "numberOfWebsocketSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Value, oldWebsocketSinksCounter) receivedChan := make(chan []byte, 2) _, dontKeepAliveChan, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, TAIL_PATH+"?app=myMetricsApp") WaitForWebsocketRegistration() assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Name, "numberOfDumpSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Value, oldDumpSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Name, "numberOfSyslogSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Value, oldSyslogSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Name, "numberOfWebsocketSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Value, oldWebsocketSinksCounter+1) dontKeepAliveChan <- true WaitForWebsocketRegistration() assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Name, "numberOfDumpSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[0].Value, oldDumpSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Name, "numberOfSyslogSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[1].Value, oldSyslogSinksCounter+1) assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Name, "numberOfWebsocketSinks") assert.Equal(t, TestMessageRouter.Emit().Metrics[2].Value, oldWebsocketSinksCounter) }