ldservices

func ClientSideStreamingServiceHandler ¶ added in v1.1.0

func ClientSideStreamingServiceHandler(
	initialEvent eventsource.Event,
	eventsCh <-chan eventsource.Event,
) (http.Handler, io.Closer)

ClientSideStreamingServiceHandler creates an HTTP handler to mimic the LaunchDarkly client-side streaming service.

This is the same as StreamingServiceHandler, but enforces that the request path and method correspond to one of the client-side/mobile endpoints.

initialData := ldservices.NewClientSDKData().Flags(flag1, flag2) // all clients will get this in a "put" event
eventsCh := make(chan eventsource.Event)
handler, closer := ldservices.ClientSideStreamingHandler(initialData, eventsCh)
server := httptest.NewServer(handler)
eventsCh <- myUpdatedFlag // push a "patch" event
closer.Close() // force any current stream connections to be closed

func NewSSEEvent ¶

func NewSSEEvent(id, event, data string) eventsource.Event

NewSSEEvent constructs an implementation of eventsource.Event, to be used in testing eventsource or with StreamingServiceHandler.

func ServerSideEventsServiceHandler ¶

func ServerSideEventsServiceHandler() http.Handler

ServerSideEventsServiceHandler creates an HTTP handler to mimic the LaunchDarkly server-side events service. It returns a 202 status for POSTs to the /bulk and /diagnostic paths, otherwise a 404.

func ServerSidePollingServiceHandler ¶

func ServerSidePollingServiceHandler(data interface{}) http.Handler

ServerSidePollingServiceHandler creates an HTTP handler to mimic the LaunchDarkly server-side polling service.

This handler returns JSON data for requests to /sdk/latest-all, and a 404 error for all other requests.

Since this package cannot depend on the LaunchDarkly data model types, the caller is responsible for providing an object that can be marshaled to JSON (such as ServerSDKData). If the data parameter is nil, the default response is an empty JSON object {}. The data is marshalled again for each request.

data := NewServerSDKData().Flags(flag1, flag2)
handler := PollingServiceHandler(data)

If you want the mock service to return different responses at different points during a test, you can either provide a *ServerSDKData and modify its properties, or use a DelegatingHandler or SequentialHandler that can be made to delegate to the ServerSidePollingServiceHandler at one time but a different handler at another time.

func ServerSideStreamingServiceHandler ¶

func ServerSideStreamingServiceHandler(
	initialEvent eventsource.Event,
	eventsCh <-chan eventsource.Event,
) (http.Handler, io.Closer)

ServerSideStreamingServiceHandler creates an HTTP handler to mimic the LaunchDarkly server-side streaming service.

This is the same as StreamingServiceHandler, but enforces that the request path is ServerSideSDKStreamingPath and that the method is GET.

initialData := ldservices.NewServerSDKData().Flags(flag1, flag2) // all clients will get this in a "put" event
eventsCh := make(chan eventsource.Event)
handler, closer := ldservices.ServerSideStreamingHandler(initialData, eventsCh)
server := httptest.NewServer(handler)
eventsCh <- ldservices.NewSSEEvent("", "patch", myPatchData) // push a "patch" event
closer.Close() // force any current stream connections to be closed

func StreamingServiceHandler ¶ added in v1.1.0

func StreamingServiceHandler(
	initialEvent eventsource.Event,
	eventsCh <-chan eventsource.Event,
) (http.Handler, io.Closer)

StreamingServiceHandler creates an HTTP handler that provides an SSE stream.

This is a very simplistic implementation, not suitable for use in a real server that must handle multiple clients simultaneously (it has a single channel for events, so if there are multiple requests the events will be divided up random between them). Real applications should instead use the Server type in eventsource, which provides a multiplexed publish-subscribe model.

If initialEvent is non-nil, it will be sent at the beginning of each connection; you can pass a *ServerSDKData value to generate a "put" event.

Any events that are pushed to eventsCh (if it is non-nil) will be published to the stream.

Calling Close() on the returned io.Closer causes the handler to close any active stream connections and refuse all subsequent requests. You don't need to do this unless you need to force a stream to disconnect before the test server has been shut down; shutting down the server will close connections anyway.