Example #1
0
func TestTailsLogsFor(t *testing.T) {
	expectedMessage := messagetesthelpers.MarshalledLogMessage(t, "My message", "my-app-id")

	websocketEndpoint := func(conn *websocket.Conn) {
		conn.Write(expectedMessage)
		conn.Close()
	}

	websocketServer := httptest.NewTLSServer(websocket.Handler(websocketEndpoint))
	defer websocketServer.Close()

	var redirectEndpoint = func(writer http.ResponseWriter, request *http.Request) {
		assert.Equal(t, request.URL.Path, "/tail/")
		assert.Equal(t, request.URL.RawQuery, "app=my-app-guid")
		assert.Equal(t, request.Method, "GET")
		assert.Contains(t, request.Header.Get("Authorization"), "BEARER my_access_token")

		writer.Header().Set("Location", strings.Replace(websocketServer.URL, "https", "wss", 1))
		writer.WriteHeader(http.StatusFound)
	}

	http.HandleFunc("/", redirectEndpoint)

	go http.ListenAndServe(":"+LOGGREGATOR_REDIRECTOR_PORT, nil)

	redirectServer := httptest.NewTLSServer(http.HandlerFunc(redirectEndpoint))
	defer redirectServer.Close()

	gateway := net.NewCloudControllerGateway(&testhelpers.FakeAuthenticator{})
	app := cf.Application{Name: "my-app", Guid: "my-app-guid"}
	config := &configuration.Configuration{AccessToken: "BEARER my_access_token", Target: "http://localhost"}

	loggregatorHostResolver := func(hostname string) string { return hostname }
	logsRepo := NewLoggregatorLogsRepository(config, gateway, loggregatorHostResolver)

	connected := false

	onConnect := func() {
		connected = true
	}

	tailedMessages := []*logmessage.LogMessage{}

	onMessage := func(message *logmessage.LogMessage) {
		tailedMessages = append(tailedMessages, message)
	}

	logsRepo.TailLogsFor(app, onConnect, onMessage)

	assert.Equal(t, len(tailedMessages), 1)
	actualMessage, err := proto.Marshal(tailedMessages[0])
	assert.NoError(t, err)
	assert.Equal(t, actualMessage, expectedMessage)

	assert.True(t, connected)
}
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
	}
}
Example #3
0
func TestRecentLogsFor(t *testing.T) {
	expectedMessage := messagetesthelpers.MarshalledLogMessage(t, "My message", "my-app-id")
	message, err := logmessage.ParseMessage(expectedMessage)
	assert.NoError(t, err)

	ts := httptest.NewTLSServer(http.HandlerFunc(recentLogsEndpoint(message)))
	defer ts.Close()

	app := cf.Application{Name: "my-app", Guid: "my-app-guid"}
	config := &configuration.Configuration{AccessToken: "BEARER my_access_token", Target: ts.URL}
	gateway := net.NewCloudControllerGateway(&testhelpers.FakeAuthenticator{})
	loggregatorHostResolver := func(hostname string) string { return hostname }
	logsRepo := NewLoggregatorLogsRepository(config, gateway, loggregatorHostResolver)

	logs, err := logsRepo.RecentLogsFor(app)
	assert.NoError(t, err)

	assert.Equal(t, len(logs), 1)
	actualMessage, err := proto.Marshal(logs[0])
	assert.NoError(t, err)
	assert.Equal(t, actualMessage, expectedMessage)
}
Example #4
0
func TestFromLogMessageProtobuffer(t *testing.T) {
	message := testhelpers.MarshalledLogMessage(t, "message", "my_app_id")
	appid, err := FromProtobufferMessage(message)
	assert.NoError(t, err)
	assert.Equal(t, "my_app_id", appid)
}