astra
/
go-mastodon
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
go-mastodon/streaming_ws_test.go

299 lines
7.6 KiB
Go
Raw Normal View History

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"
"testing"
"time"
"github.com/gorilla/websocket"
)
func TestStreamingWSPublic(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())
q, err := client.StreamingWSPublic(ctx)
if err != nil {
t.Fatalf("should not be fail: %v", err)
}
wsTest(t, q, cancel)
}
func TestStreamingWSPublicLocal(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())
q, err := client.StreamingWSPublicLocal(ctx)
if err != nil {
t.Fatalf("should not be fail: %v", err)
}
wsTest(t, q, cancel)
}
func TestStreamingWSUser(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())
q, err := client.StreamingWSUser(ctx)
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())
q, err := client.StreamingWSHashtag(ctx, "zzz")
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 TestStreamingWSHashtagLocal(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())
q, err := client.StreamingWSHashtagLocal(ctx, "zzz")
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,
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()
close(q)
})
events := []Event{}
for e := range q {
events = append(events, e)
}
Add TestHandleWS
2017-04-23 12:47:03 +02:00
if len(events) != 4 {
Add streaming API WebSocket test
2017-04-23 10:28:31 +02:00
t.Fatalf("result should be two: %d", len(events))
}
if events[0].(*UpdateEvent).Status.Content != "foo" {
t.Fatalf("want %q but %q", "foo", events[0].(*UpdateEvent).Status.Content)
}
Add TestHandleWS
2017-04-23 12:47:03 +02:00
if events[1].(*NotificationEvent).Notification.ID != 123 {
t.Fatalf("want %d but %d", 123, events[1].(*NotificationEvent).Notification.ID)
}
if events[2].(*DeleteEvent).ID != 1234567 {
t.Fatalf("want %d but %d", 1234567, events[2].(*DeleteEvent).ID)
Add streaming API WebSocket test
2017-04-23 10:28:31 +02:00
}
Add TestHandleWS
2017-04-23 12:47:03 +02:00
if errorEvent, ok := events[3].(*ErrorEvent); !ok {
t.Fatalf("should be fail: %v", errorEvent.err)
}
}
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()
Add TestStreamingWS
2017-04-23 13:04:06 +02:00
_, err := client.StreamingWSPublicLocal(context.Background())
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()
q, err := client.StreamingWSPublicLocal(ctx)
if err != nil {
t.Fatalf("should not be fail: %v", err)
}
go func() {
e := <-q
if errorEvent, ok := e.(*ErrorEvent); !ok {
t.Fatalf("should be fail: %v", errorEvent.err)
}
}()
}
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
go func() {
e := <-q
if errorEvent, ok := e.(*ErrorEvent); !ok {
t.Fatalf("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()
go func() {
e := <-q
if errorEvent, ok := e.(*ErrorEvent); !ok {
t.Fatalf("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)
}
go func() {
e := <-q
if errorEvent, ok := e.(*ErrorEvent); !ok {
t.Fatalf("should be fail: %v", errorEvent.err)
}
}()
client.handleWS(context.Background(), "ws://"+ts.Listener.Addr().String(), q)
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)
}
_, rawurl, err := client.dial("ws://" + ts.Listener.Addr().String())
if err == nil {
t.Fatalf("should not 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)
}
}
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)
}
}