go-mastodon/streaming_ws_test.go

package mastodon

import (
	"context"
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"
	"time"

	"github.com/gorilla/websocket"
)

func TestStreamingWSUser(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(wsMock))
	defer ts.Close()

	client := NewClient(&Config{Server: ts.URL}).NewWSClient()
	ctx, cancel := context.WithCancel(context.Background())
	q, err := client.StreamingWSUser(ctx)
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}

	wsTest(t, q, cancel)
}

func TestStreamingWSPublic(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(wsMock))
	defer ts.Close()

	client := NewClient(&Config{Server: ts.URL}).NewWSClient()
	ctx, cancel := context.WithCancel(context.Background())
	q, err := client.StreamingWSPublic(ctx, false)
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}

	wsTest(t, q, cancel)
}

func TestStreamingWSHashtag(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(wsMock))
	defer ts.Close()

	client := NewClient(&Config{Server: ts.URL}).NewWSClient()
	ctx, cancel := context.WithCancel(context.Background())
	q, err := client.StreamingWSHashtag(ctx, "zzz", true)
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	wsTest(t, q, cancel)

	ctx, cancel = context.WithCancel(context.Background())
	q, err = client.StreamingWSHashtag(ctx, "zzz", false)
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	wsTest(t, q, cancel)
}

func wsMock(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/api/v1/streaming" {
		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
		return
	}

	u := websocket.Upgrader{}
	conn, err := u.Upgrade(w, r, nil)
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}
	defer conn.Close()

	err = conn.WriteMessage(websocket.TextMessage,
		[]byte(`{"event":"update","payload":"{\"content\":\"foo\"}"}`))
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}

	err = conn.WriteMessage(websocket.TextMessage,
		[]byte(`{"event":"status.update","payload":"{\"content\":\"bar\"}"}`))
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}

	err = conn.WriteMessage(websocket.TextMessage,
		[]byte(`{"event":"notification","payload":"{\"id\":123}"}`))
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}

	err = conn.WriteMessage(websocket.TextMessage,
		[]byte(`{"event":"delete","payload":1234567}`))
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}

	err = conn.WriteMessage(websocket.TextMessage,
		[]byte(`{"event":"update","payload":"<html></html>"}`))
	if err != nil {
		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		return
	}

	time.Sleep(10 * time.Second)
}

func wsTest(t *testing.T, q chan Event, cancel func()) {
	time.AfterFunc(time.Second, func() {
		cancel()
	})
	events := []Event{}
	for e := range q {
		events = append(events, e)
	}
	if len(events) != 7 {
		t.Fatalf("result should be seven: %d", len(events))
	}
	if events[0].(*UpdateEvent).Status.Content != "foo" {
		t.Fatalf("want %q but %q", "foo", events[0].(*UpdateEvent).Status.Content)
	}
	if events[1].(*UpdateEditEvent).Status.Content != "bar" {
		t.Fatalf("want %q but %q", "bar", events[1].(*UpdateEditEvent).Status.Content)
	}
	if events[2].(*NotificationEvent).Notification.ID != "123" {
		t.Fatalf("want %q but %q", "123", events[2].(*NotificationEvent).Notification.ID)
	}
	if events[3].(*DeleteEvent).ID != "1234567" {
		t.Fatalf("want %q but %q", "1234567", events[3].(*DeleteEvent).ID)
	}
	if errorEvent, ok := events[4].(*ErrorEvent); !ok {
		t.Fatalf("should be fail: %v", errorEvent.err)
	}
	if errorEvent, ok := events[5].(*ErrorEvent); !ok {
		t.Fatalf("should be fail: %v", errorEvent.err)
	}
	if errorEvent, ok := events[6].(*ErrorEvent); !ok {
		t.Fatalf("should be fail: %v", errorEvent.err)
	}
}

func TestStreamingWS(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(wsMock))
	defer ts.Close()

	client := NewClient(&Config{Server: ":"}).NewWSClient()
	_, err := client.StreamingWSPublic(context.Background(), true)
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	client = NewClient(&Config{Server: ts.URL}).NewWSClient()
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	q, err := client.StreamingWSPublic(ctx, true)
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		e := <-q
		if errorEvent, ok := e.(*ErrorEvent); !ok {
			t.Errorf("should be fail: %v", errorEvent.err)
		}
	}()
	wg.Wait()
}

func TestHandleWS(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		u := websocket.Upgrader{}
		conn, err := u.Upgrade(w, r, nil)
		if err != nil {
			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
			return
		}
		defer conn.Close()

		err = conn.WriteMessage(websocket.TextMessage,
			[]byte(`<html></html>`))
		if err != nil {
			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
			return
		}

		time.Sleep(10 * time.Second)
	}))
	defer ts.Close()

	q := make(chan Event)
	client := NewClient(&Config{}).NewWSClient()

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		e := <-q
		if errorEvent, ok := e.(*ErrorEvent); !ok {
			t.Errorf("should be fail: %v", errorEvent.err)
		}
	}()
	err := client.handleWS(context.Background(), ":", q)
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	wg.Add(1)
	go func() {
		defer wg.Done()
		e := <-q
		if errorEvent, ok := e.(*ErrorEvent); !ok {
			t.Errorf("should be fail: %v", errorEvent.err)
		}
	}()
	err = client.handleWS(ctx, "ws://"+ts.Listener.Addr().String(), q)
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		e := <-q
		if errorEvent, ok := e.(*ErrorEvent); !ok {
			t.Errorf("should be fail: %v", errorEvent.err)
		}
	}()
	client.handleWS(context.Background(), "ws://"+ts.Listener.Addr().String(), q)

	wg.Wait()
}

func TestDialRedirect(t *testing.T) {
	client := NewClient(&Config{}).NewWSClient()
	_, err := client.dialRedirect(":")
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}
}

func TestDial(t *testing.T) {
	canErr := true
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if canErr {
			canErr = false
			http.Redirect(w, r, ":", http.StatusMovedPermanently)
			return
		}

		http.Redirect(w, r, "http://www.example.com/", http.StatusMovedPermanently)
	}))
	defer ts.Close()

	client := NewClient(&Config{}).NewWSClient()
	_, _, err := client.dial(":")
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	_, _, err = client.dial("ws://" + ts.Listener.Addr().String())
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	_, rawurl, err := client.dial("ws://" + ts.Listener.Addr().String())
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	if rawurl != "ws://www.example.com/" {
		t.Fatalf("want %q but %q", "ws://www.example.com/", rawurl)
	}
}

func TestChangeWebSocketScheme(t *testing.T) {
	_, err := changeWebSocketScheme(":")
	if err == nil {
		t.Fatalf("should be fail: %v", err)
	}

	u, err := changeWebSocketScheme("http://example.com/")
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	if u.Scheme != "ws" {
		t.Fatalf("want %q but %q", "ws", u.Scheme)
	}

	u, err = changeWebSocketScheme("https://example.com/")
	if err != nil {
		t.Fatalf("should not be fail: %v", err)
	}
	if u.Scheme != "wss" {
		t.Fatalf("want %q but %q", "wss", u.Scheme)
	}
}
Add WebSocket implementation of streaming API 2017-04-23 08:42:57 +02:00			`package mastodon`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00
			`import (`
			`"context"`
			`"net/http"`
			`"net/http/httptest"`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`"sync"`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`"testing"`
			`"time"`

			`"github.com/gorilla/websocket"`
			`)`

Fix order of streaming WebSocket test 2017-04-30 15:16:50 +02:00			`func TestStreamingWSUser(t *testing.T) {`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`ts := httptest.NewServer(http.HandlerFunc(wsMock))`
			`defer ts.Close()`

Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{Server: ts.URL}).NewWSClient()`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`ctx, cancel := context.WithCancel(context.Background())`
Fix order of streaming WebSocket test 2017-04-30 15:16:50 +02:00			`q, err := client.StreamingWSUser(ctx)`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`

			`wsTest(t, q, cancel)`
			`}`

Fix order of streaming WebSocket test 2017-04-30 15:16:50 +02:00			`func TestStreamingWSPublic(t *testing.T) {`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`ts := httptest.NewServer(http.HandlerFunc(wsMock))`
			`defer ts.Close()`

Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{Server: ts.URL}).NewWSClient()`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`ctx, cancel := context.WithCancel(context.Background())`
Fix order of streaming WebSocket test 2017-04-30 15:16:50 +02:00			`q, err := client.StreamingWSPublic(ctx, false)`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`

			`wsTest(t, q, cancel)`
			`}`
Add TestDial 2017-04-23 11:42:13 +02:00
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`func TestStreamingWSHashtag(t *testing.T) {`
			`ts := httptest.NewServer(http.HandlerFunc(wsMock))`
			`defer ts.Close()`

Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{Server: ts.URL}).NewWSClient()`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`ctx, cancel := context.WithCancel(context.Background())`
Fix TestStreamingWSHashtag 2017-04-28 07:46:19 +02:00			`q, err := client.StreamingWSHashtag(ctx, "zzz", true)`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
Fix TestStreamingWSHashtag 2017-04-28 07:46:19 +02:00			`wsTest(t, q, cancel)`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00
Fix TestStreamingWSHashtag 2017-04-28 07:46:19 +02:00			`ctx, cancel = context.WithCancel(context.Background())`
			`q, err = client.StreamingWSHashtag(ctx, "zzz", false)`
			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`wsTest(t, q, cancel)`
			`}`

			`func wsMock(w http.ResponseWriter, r *http.Request) {`
			`if r.URL.Path != "/api/v1/streaming" {`
			`http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)`
			`return`
			`}`

			`u := websocket.Upgrader{}`
			`conn, err := u.Upgrade(w, r, nil)`
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`
			`defer conn.Close()`

			`err = conn.WriteMessage(websocket.TextMessage,`
			[]byte(`{"event":"update","payload":"{\"content\":\"foo\"}"}`))
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`err = conn.WriteMessage(websocket.TextMessage,`
			[]byte(`{"event":"status.update","payload":"{\"content\":\"bar\"}"}`))
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`err = conn.WriteMessage(websocket.TextMessage,`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			[]byte(`{"event":"notification","payload":"{\"id\":123}"}`))
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

			`err = conn.WriteMessage(websocket.TextMessage,`
			[]byte(`{"event":"delete","payload":1234567}`))
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

			`err = conn.WriteMessage(websocket.TextMessage,`
			[]byte(`{"event":"update","payload":"<html></html>"}`))
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

			`time.Sleep(10 * time.Second)`
			`}`

			`func wsTest(t *testing.T, q chan Event, cancel func()) {`
			`time.AfterFunc(time.Second, func() {`
			`cancel()`
			`})`
			`events := []Event{}`
			`for e := range q {`
			`events = append(events, e)`
			`}`
Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`if len(events) != 7 {`
			`t.Fatalf("result should be seven: %d", len(events))`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`}`
			`if events[0].(*UpdateEvent).Status.Content != "foo" {`
			`t.Fatalf("want %q but %q", "foo", events[0].(*UpdateEvent).Status.Content)`
			`}`
Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`if events[1].(*UpdateEditEvent).Status.Content != "bar" {`
			`t.Fatalf("want %q but %q", "bar", events[1].(*UpdateEditEvent).Status.Content)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`
Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`if events[2].(*NotificationEvent).Notification.ID != "123" {`
			`t.Fatalf("want %q but %q", "123", events[2].(*NotificationEvent).Notification.ID)`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`}`
Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`if events[3].(*DeleteEvent).ID != "1234567" {`
			`t.Fatalf("want %q but %q", "1234567", events[3].(*DeleteEvent).ID)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`
Fix WebSocket close 2017-04-30 15:14:02 +02:00			`if errorEvent, ok := events[4].(*ErrorEvent); !ok {`
			`t.Fatalf("should be fail: %v", errorEvent.err)`
			`}`
			`if errorEvent, ok := events[5].(*ErrorEvent); !ok {`
			`t.Fatalf("should be fail: %v", errorEvent.err)`
			`}`
Add support for edited statuses ActivityPub supports "status.update" for editing statuses. These should be made available for streams. 2022-12-21 07:37:57 +01:00			`if errorEvent, ok := events[6].(*ErrorEvent); !ok {`
			`t.Fatalf("should be fail: %v", errorEvent.err)`
			`}`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`

Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`func TestStreamingWS(t *testing.T) {`
			`ts := httptest.NewServer(http.HandlerFunc(wsMock))`
			`defer ts.Close()`

Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{Server: ":"}).NewWSClient()`
Fix streaming_ws local 2017-04-28 07:31:08 +02:00			`_, err := client.StreamingWSPublic(context.Background(), true)`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`

Add WSClient 2017-04-24 06:55:07 +02:00			`client = NewClient(&Config{Server: ts.URL}).NewWSClient()`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`ctx, cancel := context.WithCancel(context.Background())`
			`cancel()`
Fix streaming_ws local 2017-04-28 07:31:08 +02:00			`q, err := client.StreamingWSPublic(ctx, true)`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`var wg sync.WaitGroup`
			`wg.Add(1)`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`go func() {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`defer wg.Done()`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`e := <-q`
			`if errorEvent, ok := e.(*ErrorEvent); !ok {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`t.Errorf("should be fail: %v", errorEvent.err)`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`}`
			`}()`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`wg.Wait()`
Add TestStreamingWS 2017-04-23 13:04:06 +02:00			`}`

Add TestHandleWS 2017-04-23 12:47:03 +02:00			`func TestHandleWS(t *testing.T) {`
			`ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {`
			`u := websocket.Upgrader{}`
			`conn, err := u.Upgrade(w, r, nil)`
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`
			`defer conn.Close()`

			`err = conn.WriteMessage(websocket.TextMessage,`
			[]byte(`<html></html>`))
			`if err != nil {`
			`http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)`
			`return`
			`}`

			`time.Sleep(10 * time.Second)`
			`}))`
			`defer ts.Close()`

			`q := make(chan Event)`
Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{}).NewWSClient()`
Add TestHandleWS 2017-04-23 12:47:03 +02:00
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`var wg sync.WaitGroup`
			`wg.Add(1)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`go func() {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`defer wg.Done()`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`e := <-q`
			`if errorEvent, ok := e.(*ErrorEvent); !ok {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`t.Errorf("should be fail: %v", errorEvent.err)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`
			`}()`
			`err := client.handleWS(context.Background(), ":", q)`
			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`

			`ctx, cancel := context.WithCancel(context.Background())`
			`cancel()`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`wg.Add(1)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`go func() {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`defer wg.Done()`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`e := <-q`
			`if errorEvent, ok := e.(*ErrorEvent); !ok {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`t.Errorf("should be fail: %v", errorEvent.err)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`
			`}()`
			`err = client.handleWS(ctx, "ws://"+ts.Listener.Addr().String(), q)`
			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`

fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`wg.Add(1)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`go func() {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`defer wg.Done()`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`e := <-q`
			`if errorEvent, ok := e.(*ErrorEvent); !ok {`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00			`t.Errorf("should be fail: %v", errorEvent.err)`
Add TestHandleWS 2017-04-23 12:47:03 +02:00			`}`
			`}()`
			`client.handleWS(context.Background(), "ws://"+ts.Listener.Addr().String(), q)`
fix go vet warnings: call to (*T).Fatalf from a non-test goroutine The goroutine started from test must not call t.Fatal, but t.Error. Adds a sync.WaitGroup to make sure all goroutines have a chance to report an error before test stops. 2022-12-12 22:27:50 +01:00
			`wg.Wait()`
Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`}`

Add TestDialRedirect 2017-04-23 11:46:41 +02:00			`func TestDialRedirect(t *testing.T) {`
Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{}).NewWSClient()`
Add TestDialRedirect 2017-04-23 11:46:41 +02:00			`_, err := client.dialRedirect(":")`
			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`
			`}`

Add TestDial 2017-04-23 11:42:13 +02:00			`func TestDial(t *testing.T) {`
			`canErr := true`
			`ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {`
			`if canErr {`
			`canErr = false`
			`http.Redirect(w, r, ":", http.StatusMovedPermanently)`
			`return`
			`}`

			`http.Redirect(w, r, "http://www.example.com/", http.StatusMovedPermanently)`
			`}))`
			`defer ts.Close()`

Add WSClient 2017-04-24 06:55:07 +02:00			`client := NewClient(&Config{}).NewWSClient()`
Add TestDial 2017-04-23 11:42:13 +02:00			`_, _, err := client.dial(":")`
			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`

Fix ineffectual assignments - Don't assign variables we don't end up using - Added missing error check in test 2019-08-08 11:21:21 +02:00			`_, _, err = client.dial("ws://" + ts.Listener.Addr().String())`
Add TestDial 2017-04-23 11:42:13 +02:00			`if err == nil {`
Fix error message 2017-04-24 10:25:56 +02:00			`t.Fatalf("should be fail: %v", err)`
Add TestDial 2017-04-23 11:42:13 +02:00			`}`

Fix ineffectual assignments - Don't assign variables we don't end up using - Added missing error check in test 2019-08-08 11:21:21 +02:00			`_, rawurl, err := client.dial("ws://" + ts.Listener.Addr().String())`
Add TestDial 2017-04-23 11:42:13 +02:00			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
			`if rawurl != "ws://www.example.com/" {`
			`t.Fatalf("want %q but %q", "ws://www.example.com/", rawurl)`
			`}`
			`}`

Add streaming API WebSocket test 2017-04-23 10:28:31 +02:00			`func TestChangeWebSocketScheme(t *testing.T) {`
			`_, err := changeWebSocketScheme(":")`
			`if err == nil {`
			`t.Fatalf("should be fail: %v", err)`
			`}`

			`u, err := changeWebSocketScheme("http://example.com/")`
			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
			`if u.Scheme != "ws" {`
			`t.Fatalf("want %q but %q", "ws", u.Scheme)`
			`}`

			`u, err = changeWebSocketScheme("https://example.com/")`
			`if err != nil {`
			`t.Fatalf("should not be fail: %v", err)`
			`}`
			`if u.Scheme != "wss" {`
			`t.Fatalf("want %q but %q", "wss", u.Scheme)`
			`}`
			`}`