Eventually(incomingChan).Should(BeClosed())
close(done)
})
It("sends a keepalive to the server", func() {
messageCountingServer := &messageCountingHandler{}
testServer := httptest.NewServer(websocket.Handler(messageCountingServer.handle))
defer testServer.Close()
consumer.KeepAlive = 10 * time.Millisecond
connection = consumer.New("ws://"+testServer.Listener.Addr().String(), tlsSettings, consumerProxyFunc)
incomingChan, err = connection.Tail(appGuid, authToken)
defer connection.Close()
Eventually(messageCountingServer.count).Should(BeNumerically("~", 10, 2))
})
It("sends messages for a specific app", func() {
appGuid = "the-app-guid"
perform()
close(messagesToSend)
Eventually(fakeHandler.getLastURL).Should(ContainSubstring("/tail/?app=the-app-guid"))
})
It("sends an Authorization header with an access token", func() {
authToken = "auth-token"
perform()
var appGuid, authToken string
var connection consumer.LoggregatorConsumer
BeforeEach(func() {
var err error
appGuid = os.Getenv("TEST_APP_GUID")
loggregatorEndpoint := os.Getenv("LOGGREGATOR_ENDPOINT")
connection = consumer.New(loggregatorEndpoint, &tls.Config{InsecureSkipVerify: true}, nil)
authToken, err = getAuthToken()
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {
connection.Close()
})
It("should return data for recent", func() {
messages, err := connection.Recent(appGuid, authToken)
Expect(err).NotTo(HaveOccurred())
Expect(messages).To(ContainElement(ContainSubstring("Tick")))
})
It("should return data for tail", func(done Done) {
messagesChan, err := connection.Tail(appGuid, authToken)
Expect(err).NotTo(HaveOccurred())
for m := range messagesChan {
if strings.Contains(string(m.GetMessage()), "Tick") {
break
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring(http.StatusText(http.StatusBadRequest)))
})
})
})
Describe("Close", func() {
BeforeEach(func() {
testServer = httptest.NewServer(websocket.Handler(fakeHandler.handle))
endpoint = "ws://" + testServer.Listener.Addr().String()
})
Context("when a connection is not open", func() {
It("returns an error", func() {
connection = consumer.New(endpoint, nil, nil)
err := connection.Close()
Expect(err.Error()).To(Equal("connection does not exist"))
})
})
Context("when a connection is open", func() {
It("closes any open channels", func(done Done) {
connection = consumer.New(endpoint, nil, nil)
incomingChan, err := connection.Tail("app-guid", "auth-token")
close(fakeHandler.closeConnection)
Eventually(fakeHandler.wasCalled).Should(BeTrue())
connection.Close()
expected := "CEF:0|cloud_foundry|loggregator_trafficcontroller|1.0|GET /firehose/foo|GET /firehose/foo|0|"
Eventually(testContents).Should(ContainSubstring(expected))
})
})
Context("with legacy endpoints", func() {
var legacyConsumer loggregator_consumer.LoggregatorConsumer
JustBeforeEach(func() {
tcURL := fmt.Sprintf("ws://%s:%d", localIPAddress, TRAFFIC_CONTROLLER_LEGACY_PORT)
legacyConsumer = loggregator_consumer.New(tcURL, &tls.Config{}, nil)
})
AfterEach(func() {
legacyConsumer.Close()
})
It("logs tail access", func() {
legacyConsumer.Tail(APP_ID, AUTH_TOKEN)
expected := fmt.Sprintf("CEF:0|cloud_foundry|loggregator_trafficcontroller|1.0|GET /tail/?app=%s|GET /tail/?app=%[1]s|0|", APP_ID)
Eventually(testContents).Should(ContainSubstring(expected))
})
It("logs recent access", func() {
legacyConsumer.Recent(APP_ID, AUTH_TOKEN)
expected := fmt.Sprintf("CEF:0|cloud_foundry|loggregator_trafficcontroller|1.0|GET /recent?app=%s|GET /recent?app=%[1]s|0|", APP_ID)
Eventually(testContents).Should(ContainSubstring(expected))
})