Golang LoggregatorConsumer.Close方法代码示例

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