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 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 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 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 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 TestProxyWhenAuthorizationFailsThroughQueryParams(t *testing.T) {
proxy := NewProxy(
"localhost:62062",
[]*hasher.Hasher{
hasher.NewHasher([]string{"localhost:62032"}),
},
testhelpers.SuccessfulAuthorizer,
loggertesthelper.Logger(),
)
go proxy.Start()
time.Sleep(time.Millisecond * 50)
config, err := websocket.NewConfig("ws://localhost:62061/?app=myApp&authorization="+url.QueryEscape(testhelpers.INVALID_AUTHENTICATION_TOKEN), "http://localhost")
assert.NoError(t, err)
receivedChan := ClientWithAuth(t, "62062", "/?app=myApp", config)
select {
case data := <-receivedChan:
messagetesthelpers.AssertProtoBufferMessageEquals(t, "Error: Invalid authorization", data)
case <-time.After(1 * time.Second):
t.Error("Did not receive response within one second")
}
_, stillOpen := <-receivedChan
assert.False(t, stillOpen)
}
func TestProxyWithoutAuthorization(t *testing.T) {
proxy := NewProxy(
"localhost:62061",
[]*hasher.Hasher{
hasher.NewHasher([]string{"localhost:62032"}),
},
testhelpers.SuccessfulAuthorizer,
loggertesthelper.Logger(),
)
go proxy.Start()
time.Sleep(time.Millisecond * 50)
config, err := websocket.NewConfig("ws://localhost:62061/?app=myApp", "http://localhost")
assert.NoError(t, err)
receivedChan := ClientWithAuth(t, "62061", "/?app=myApp", config)
select {
case data := <-receivedChan:
messagetesthelpers.AssertProtoBufferMessageEquals(t, "Error: Authorization not provided", data)
case <-time.After(1 * time.Second):
t.Error("Did not receive response within one second")
}
_, stillOpen := <-receivedChan
assert.False(t, stillOpen)
}
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 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 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 TestProxyWhenLogTargetisinvalid(t *testing.T) {
proxy := NewProxy(
"localhost:62060",
[]*hasher.Hasher{
hasher.NewHasher([]string{"localhost:62032"}),
},
testhelpers.SuccessfulAuthorizer,
loggertesthelper.Logger(),
)
go proxy.Start()
time.Sleep(time.Millisecond * 50)
receivedChan := Client(t, "62060", "/invalid_target")
select {
case data := <-receivedChan:
messagetesthelpers.AssertProtoBufferMessageEquals(t, "Error: Invalid target", data)
case <-time.After(1 * time.Second):
t.Error("Did not receive response within one second")
}
_, stillOpen := <-receivedChan
assert.False(t, stillOpen)
}
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
}