Merge pull request #26 from posener/go1.10

Use go1.10 new features

Author: Eyal Posener

.travis.yml

@@ -1,15 +1,13 @@
 language: go
 sudo: false
 go:
-  - 1.7
-  - 1.8
-  - tip
+  - master
 
 before_install:
   - go get -u -t ./...
 
 script:
-  - ./go.test.sh
+  - go test -count 20 -v -race -coverprofile=coverage.txt -covermode=atomic ./...
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)

README.md

@@ -39,7 +39,7 @@ func TestHandler(t *testing.T) {
 -	s := httptest.NewServer(h)
 -	defer s.Close()
 -	d := websocket.Dialer{}
-+	d := wstest.NewDialer(h, nil)  // or t.Log instead of nil
++	d := wstest.NewDialer(h)
 
 -	c, resp, err := d.Dial("ws://" + s.Listener.Addr().String() + "/ws", nil)
 +	c, resp, err := d.Dial("ws://" + "whatever" + "/ws", nil)

dialer.go

@@ -12,7 +12,6 @@ import (
 	"net/http/httptest"
 
 	"github.com/gorilla/websocket"
-	"github.com/posener/wstest/pipe"
 )
 
 // NewDialer creates a wstest recorder to an http.Handler which accepts websocket upgrades.
@@ -21,11 +20,9 @@ import (
 // client running on the current program flow
 //
 // h is an http.Handler that handles websocket connections.
-// debugLog is a function for a log.Println-like function for printing everything that
-// is passed over the connection. Can be set to nil if no logs are needed.
 // It returns a *websocket.Dial struct, which can then be used to dial to the handler.
-func NewDialer(h http.Handler, debugLog pipe.Println) *websocket.Dialer {
-	client, server := pipe.New(debugLog)
+func NewDialer(h http.Handler) *websocket.Dialer {
+	client, server := net.Pipe()
 	conn := &recorder{server: server}
 
 	// run the runServer in a goroutine, so when the Dial send the request to

dialer_test.go

@@ -1,140 +1,117 @@
 package wstest_test
 
 import (
-	"context"
 	"fmt"
-	"net"
 	"net/http"
-	"strings"
 	"testing"
 	"time"
 
 	"github.com/gorilla/websocket"
-
 	"github.com/posener/wstest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // TestClient demonstrate the usage of wstest package
 func TestClient(t *testing.T) {
 	t.Parallel()
 	var (
-		s = &handler{Upgraded: make(chan struct{})}
-		d = wstest.NewDialer(s, t.Log)
+		s    = &handler{Upgraded: make(chan struct{})}
+		d    = wstest.NewDialer(s)
+		done = make(chan struct{})
 	)
 
 	c, resp, err := d.Dial("ws://example.org/ws", nil)
-	if err != nil {
-		t.Fatalf("Failed connecting to s: %s", err)
-	}
+	require.Nil(t, err)
 
 	<-s.Upgraded
 
-	if got, want := resp.StatusCode, http.StatusSwitchingProtocols; got != want {
-		t.Errorf("resp.StatusCode = %q, want %q", got, want)
-	}
+	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
 
 	for i := 0; i < 3; i++ {
 		msg := fmt.Sprintf("hello, world! %d", i)
 
-		err := c.WriteMessage(websocket.TextMessage, []byte(msg))
-		if err != nil {
-			t.Fatal(err)
-		}
+		go func() {
+			err := c.WriteMessage(websocket.TextMessage, []byte(msg))
+			require.Nil(t, err)
+			done <- struct{}{}
+		}()
 
 		mT, m, err := s.ReadMessage()
-		if err != nil {
-			t.Fatal(err)
-		}
+		require.Nil(t, err)
 
-		if want, got := msg, string(m); want != got {
-			t.Errorf("dialer got %q, want  %q", got, want)
-		}
-		if want, got := websocket.TextMessage, mT; want != got {
-			t.Errorf("message type = %q, want %q", got, want)
-		}
+		assert.Equal(t, msg, string(m))
+		assert.Equal(t, websocket.TextMessage, mT)
+		<-done
 
-		s.WriteMessage(websocket.TextMessage, []byte(msg))
-		if err != nil {
-			t.Fatal(err)
-		}
+		go func() {
+			err := s.WriteMessage(websocket.TextMessage, []byte(msg))
+			require.Nil(t, err)
+			done <- struct{}{}
+		}()
 
 		mT, m, err = c.ReadMessage()
-		if err != nil {
-			t.Fatal(err)
-		}
+		require.Nil(t, err)
 
-		if want, got := msg, string(m); want != got {
-			t.Errorf("client got %q, want  %q", got, want)
-		}
-		if want, got := websocket.TextMessage, mT; want != got {
-			t.Errorf("message type = %q , want %q", got, want)
-		}
+		assert.Equal(t, msg, string(m))
+		assert.Equal(t, websocket.TextMessage, mT)
+		<-done
 	}
 
 	err = c.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.Nil(t, err)
 
 	err = s.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.Nil(t, err)
 }
 
 // TestConcurrent tests concurrent reads and writes from a connection
 func TestConcurrent(t *testing.T) {
 	t.Parallel()
 	var (
 		s     = &handler{Upgraded: make(chan struct{})}
-		d     = wstest.NewDialer(s, nil)
+		d     = wstest.NewDialer(s)
 		count = 20
 	)
 
 	c, _, err := d.Dial("ws://example.org/ws", nil)
-	if err != nil {
-		t.Fatalf("Failed connecting to s: %s", err)
-	}
+	require.Nil(t, err)
 
 	<-s.Upgraded
 
 	for _, pair := range []struct{ src, dst *websocket.Conn }{{s.Conn, c}, {c, s.Conn}} {
 		go func() {
 			for i := 0; i < count; i++ {
-				pair.src.WriteJSON(i)
+				err := pair.src.WriteJSON(i)
+				require.Nil(t, err)
 			}
 		}()
 
 		received := make([]bool, count)
 
 		for i := 0; i < count; i++ {
 			var j int
-			pair.dst.ReadJSON(&j)
+			err := pair.dst.ReadJSON(&j)
+			require.Nil(t, err)
 
 			received[j] = true
 		}
 
-		missing := []int{}
+		var missing []int
 
 		for i := range received {
 			if !received[i] {
 				missing = append(missing, i)
 			}
 		}
-		if len(missing) > 0 {
-			t.Errorf("%q -> %q: Did not received: %q", pair.src.LocalAddr(), pair.dst.LocalAddr(), missing)
-		}
+		assert.Equal(t, 0, len(missing), "%q -> %q: Did not received: %q", pair.src.LocalAddr(), pair.dst.LocalAddr(), missing)
 	}
 
 	err = c.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.Nil(t, err)
 
 	err = s.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.Nil(t, err)
 }
 
 func TestBadAddress(t *testing.T) {
@@ -157,38 +134,30 @@ func TestBadAddress(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.url, func(t *testing.T) {
 			s := &handler{Upgraded: make(chan struct{})}
-			d := wstest.NewDialer(s, nil)
+			d := wstest.NewDialer(s)
 			c, resp, err := d.Dial(tt.url, nil)
-			if c != nil {
-				t.Errorf("d = %T, want nil", c)
-			}
-			if err == nil {
-				t.Error("opError is nil")
-			}
+			assert.Nil(t, c)
+			assert.NotNil(t, err)
 			if tt.code != 0 {
-				if got, want := resp.StatusCode, tt.code; got != want {
-					t.Errorf("resp.StatusCode = %q, want %q", got, want)
-				}
+				assert.Equal(t, tt.code, resp.StatusCode)
 			}
 
 			err = s.Close()
-			if err != nil {
-				t.Fatal(err)
-			}
+			require.Nil(t, err)
 		})
 	}
 }
 
+const deadlineExceeded = "deadline exceeded"
+
 // TestConnectDeadline tests connection deadlines
 func TestDeadlines(t *testing.T) {
 	t.Parallel()
 	h := &handler{Upgraded: make(chan struct{})}
-	d := wstest.NewDialer(h, nil)
+	d := wstest.NewDialer(h)
 
 	c, _, err := d.Dial("ws://example.org/ws", nil)
-	if err != nil {
-		t.Fatalf("Failed connecting to h: %q", err)
-	}
+	require.Nil(t, err)
 
 	<-h.Upgraded
 
@@ -198,27 +167,20 @@ func TestDeadlines(t *testing.T) {
 
 		// set the deadline to now, and test for timeout
 		pair.dst.SetReadDeadline(time.Now())
-		err = pair.dst.ReadJSON(i)
-		if got, want := err.Error(), context.DeadlineExceeded.Error(); !strings.Contains(got, want) {
-			t.Errorf("err = %q, not conains %q", got, want)
-		}
-		err = pair.dst.ReadJSON(i)
-		if got, want := err.Error(), context.DeadlineExceeded.Error(); !strings.Contains(got, want) {
-			t.Errorf("err = %q, not conains %q", got, want)
-		}
+		err = pair.dst.ReadJSON(&i)
+		assert.Contains(t, err.Error(), deadlineExceeded)
 
-		pair.src.WriteJSON(1)
-		err = pair.dst.ReadJSON(i)
-		if got, want := err.Error(), context.DeadlineExceeded.Error(); !strings.Contains(got, want) {
-			t.Errorf("err = %q, not conains %q", got, want)
-		}
+		err = pair.dst.ReadJSON(&i)
+		assert.Contains(t, err.Error(), deadlineExceeded)
+
+		go pair.src.WriteJSON(1)
+		err = pair.dst.ReadJSON(&i)
+		assert.Contains(t, err.Error(), deadlineExceeded)
 
 		// even after updating the deadline, should get an error
 		pair.dst.SetReadDeadline(time.Now().Add(time.Second))
-		err = pair.dst.ReadJSON(i)
-		if got, want := err.Error(), context.DeadlineExceeded.Error(); !strings.Contains(got, want) {
-			t.Errorf("err = %q, not conains %q", got, want)
-		}
+		err = pair.dst.ReadJSON(&i)
+		assert.Contains(t, err.Error(), deadlineExceeded)
 	}
 }
 
@@ -229,42 +191,35 @@ func TestConnectDeadline(t *testing.T) {
 	tests := []struct {
 		path    string
 		timeout time.Duration
-		err     error
+		wantErr bool
 	}{
 		{
-			"/ws/delay",
-			time.Millisecond,
-			context.DeadlineExceeded,
+			path:    "/ws/delay",
+			timeout: time.Millisecond,
+			wantErr: true,
 		},
 		{
-			"/ws",
-			time.Second,
-			nil,
+			path:    "/ws",
+			timeout: time.Second,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(fmt.Sprintf("%s/%s", tt.path, tt.timeout), func(t *testing.T) {
 			s := &handler{Upgraded: make(chan struct{})}
-			d := wstest.NewDialer(s, nil)
+			d := wstest.NewDialer(s)
 			d.HandshakeTimeout = tt.timeout
 			_, _, err := d.Dial("ws://example.org"+tt.path, nil)
-			if tt.err == nil {
-				if err != nil {
-					t.Errorf("err = %q, want nil", err)
-				}
-			} else {
-				if got, want := err.(*net.OpError).Err, tt.err; got != want {
-					t.Errorf("err = %q, want %q", got, want)
-				}
+			if tt.wantErr {
+				assert.NotNil(t, err)
+				return
 			}
 
-			if tt.err == nil {
-				select {
-				case <-s.Upgraded:
-				case <-time.After(time.Second):
-					t.Fatal("connection was not upgraded after 1s")
-				}
+			assert.Nil(t, err)
+			select {
+			case <-s.Upgraded:
+			case <-time.After(time.Second):
+				t.Fatal("connection was not upgraded after 1s")
 			}
 		})
 	}
@@ -294,12 +249,12 @@ func (s *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *handler) connect(w http.ResponseWriter, r *http.Request) {
+	defer close(s.Upgraded)
 	var err error
 	s.Conn, err = s.upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		return
 	}
-	close(s.Upgraded)
 }
 
 func (s *handler) Close() error {

example_test.go

@@ -19,7 +19,7 @@ func ExampleNewDialer() {
 		// it uses the gorilla's websocket.Dial function, over a fake net.Conn struct.
 		// it runs the handler's ServeHTTP function in a goroutine, so the handler can
 		// communicate with a client running on the current program flow
-		d = wstest.NewDialer(s, nil)
+		d = wstest.NewDialer(s)
 
 		resp string
 	)