Cleanup some tests using testify/assert

cmd/ck-server/ck-server_test.go

@@ -9,49 +9,27 @@ import (
 func TestParseBindAddr(t *testing.T) {
 	t.Run("port only", func(t *testing.T) {
 		addrs, err := resolveBindAddr([]string{":443"})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.Equal(t, ":443", addrs[0].String())
-			return
-		}
-		if addrs[0].String() != ":443" {
-			t.Errorf("expected %v got %v", ":443", addrs[0].String())
-		}
 	})
 
 	t.Run("specific address", func(t *testing.T) {
 		addrs, err := resolveBindAddr([]string{"192.168.1.123:443"})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.Equal(t, "192.168.1.123:443", addrs[0].String())
-			return
-		}
-		if addrs[0].String() != "192.168.1.123:443" {
-			t.Errorf("expected %v got %v", "192.168.1.123:443", addrs[0].String())
-		}
 	})
 
 	t.Run("ipv6", func(t *testing.T) {
 		addrs, err := resolveBindAddr([]string{"[::]:443"})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.Equal(t, "[::]:443", addrs[0].String())
-			return
-		}
-		if addrs[0].String() != "[::]:443" {
-			t.Errorf("expected %v got %v", "[::]:443", addrs[0].String())
-		}
 	})
 
 	t.Run("mixed", func(t *testing.T) {
 		addrs, err := resolveBindAddr([]string{":80", "[::]:443"})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(err)
+		assert.Equal(t, ":80", addrs[0].String())
-			return
+		assert.Equal(t, "[::]:443", addrs[1].String())
-		}
-		if addrs[0].String() != ":80" {
-			t.Errorf("expected %v got %v", ":80", addrs[0].String())
-		}
-		if addrs[1].String() != "[::]:443" {
-			t.Errorf("expected %v got %v", "[::]:443", addrs[1].String())
-		}
 	})
 }
 

internal/client/TLS_test.go

@@ -1,8 +1,8 @@
 package client
 
 import (
-	"bytes"
 	"encoding/hex"
+	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
@@ -33,11 +33,6 @@ func TestMakeServerName(t *testing.T) {
 	}
 
 	for _, p := range pairs {
-		if !bytes.Equal(makeServerName(p.serverName), p.target) {
+		assert.Equal(t, p.target, makeServerName(p.serverName))
-			t.Error(
-				"for", p.serverName,
-				"expecting", p.target,
-				"got", makeServerName(p.serverName))
-		}
 	}
 }

internal/client/auth_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"github.com/cbeuw/Cloak/internal/common"
 	"github.com/cbeuw/Cloak/internal/multiplex"
+	"github.com/stretchr/testify/assert"
 	"testing"
 	"time"
 )
@@ -64,12 +65,8 @@ func TestMakeAuthenticationPayload(t *testing.T) {
 	for _, tc := range tests {
 		func() {
 			payload, sharedSecret := makeAuthenticationPayload(tc.authInfo)
-			if payload != tc.expPayload {
+			assert.Equal(t, tc.expPayload, payload, "payload doesn't match")
-				t.Errorf("payload doesn't match:\nexp %v\ngot %v", tc.expPayload, payload)
+			assert.Equal(t, tc.expSecret, sharedSecret, "shared secret doesn't match")
-			}
-			if sharedSecret != tc.expSecret {
-				t.Errorf("secret doesn't match:\nexp %x\ngot %x", tc.expPayload, payload)
-			}
 		}()
 	}
 }

internal/multiplex/datagramBufferedPipe_test.go

@@ -1,7 +1,7 @@
 package multiplex
 
 import (
-	"bytes"
+	"github.com/stretchr/testify/assert"
 	"testing"
 	"time"
 )
@@ -11,13 +11,7 @@ func TestDatagramBuffer_RW(t *testing.T) {
 	t.Run("simple write", func(t *testing.T) {
 		pipe := NewDatagramBufferedPipe()
 		_, err := pipe.Write(&Frame{Payload: b})
-		if err != nil {
+		assert.NoError(t, err)
-			t.Error(
-				"expecting", "nil error",
-				"got", err,
-			)
-			return
-		}
 	})
 
 	t.Run("simple read", func(t *testing.T) {
@@ -25,50 +19,18 @@ func TestDatagramBuffer_RW(t *testing.T) {
 		_, _ = pipe.Write(&Frame{Payload: b})
 		b2 := make([]byte, len(b))
 		n, err := pipe.Read(b2)
-		if n != len(b) {
+		assert.NoError(t, err)
-			t.Error(
+		assert.Equal(t, len(b), n)
-				"For", "number of bytes read",
+		assert.Equal(t, b, b2)
-				"expecting", len(b),
+		assert.Equal(t, 0, pipe.buf.Len(), "buf len is not 0 after finished reading")
-				"got", n,
-			)
-			return
-		}
-		if err != nil {
-			t.Error(
-				"expecting", "nil error",
-				"got", err,
-			)
-			return
-		}
-		if !bytes.Equal(b, b2) {
-			t.Error(
-				"expecting", b,
-				"got", b2,
-			)
-		}
-		if pipe.buf.Len() != 0 {
-			t.Error("buf len is not 0 after finished reading")
-			return
-		}
-
 	})
 
 	t.Run("writing closing frame", func(t *testing.T) {
 		pipe := NewDatagramBufferedPipe()
 		toBeClosed, err := pipe.Write(&Frame{Closing: closingStream})
-		if !toBeClosed {
+		assert.NoError(t, err)
-			t.Error("should be to be closed")
+		assert.True(t, toBeClosed, "should be to be closed")
-		}
+		assert.True(t, pipe.closed, "pipe should be closed")
-		if err != nil {
-			t.Error(
-				"expecting", "nil error",
-				"got", err,
-			)
-			return
-		}
-		if !pipe.closed {
-			t.Error("expecting closed pipe, not closed")
-		}
 	})
 }
 
@@ -81,30 +43,9 @@ func TestDatagramBuffer_BlockingRead(t *testing.T) {
 	}()
 	b2 := make([]byte, len(b))
 	n, err := pipe.Read(b2)
-	if n != len(b) {
+	assert.NoError(t, err)
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes read after block is wrong")
-			"For", "number of bytes read after block",
+	assert.Equal(t, b, b2)
-			"expecting", len(b),
-			"got", n,
-		)
-		return
-	}
-	if err != nil {
-		t.Error(
-			"For", "blocked read",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b, b2) {
-		t.Error(
-			"For", "blocked read",
-			"expecting", b,
-			"got", b2,
-		)
-		return
-	}
 }
 
 func TestDatagramBuffer_CloseThenRead(t *testing.T) {
@@ -114,27 +55,7 @@ func TestDatagramBuffer_CloseThenRead(t *testing.T) {
 	b2 := make([]byte, len(b))
 	pipe.Close()
 	n, err := pipe.Read(b2)
-	if n != len(b) {
+	assert.NoError(t, err)
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes read after block is wrong")
-			"For", "number of bytes read",
+	assert.Equal(t, b, b2)
-			"expecting", len(b),
-			"got", n,
-		)
-	}
-	if err != nil {
-		t.Error(
-			"For", "simple read",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b, b2) {
-		t.Error(
-			"For", "simple read",
-			"expecting", b,
-			"got", b2,
-		)
-		return
-	}
 }

internal/multiplex/mux_test.go

@@ -108,9 +108,7 @@ func TestMultiplex(t *testing.T) {
 	streams := make([]net.Conn, numStreams)
 	for i := 0; i < numStreams; i++ {
 		stream, err := clientSession.OpenStream()
-		if err != nil {
+		assert.NoError(t, err)
-			t.Fatalf("failed to open stream: %v", err)
-		}
 		streams[i] = stream
 	}
 
@@ -123,18 +121,11 @@ func TestMultiplex(t *testing.T) {
 	// close one stream
 	closing, streams := streams[0], streams[1:]
 	err := closing.Close()
-	if err != nil {
+	assert.NoError(t, err, "couldn't close a stream")
-		t.Errorf("couldn't close a stream")
-	}
 	_, err = closing.Write([]byte{0})
-	if err != ErrBrokenStream {
+	assert.Equal(t, ErrBrokenStream, err)
-		t.Errorf("expecting error %v, got %v", ErrBrokenStream, err)
-	}
 	_, err = closing.Read(make([]byte, 1))
-	if err != ErrBrokenStream {
+	assert.Equal(t, ErrBrokenStream, err)
-		t.Errorf("expecting error %v, got %v", ErrBrokenStream, err)
-	}
-
 }
 
 func TestMux_StreamClosing(t *testing.T) {
@@ -146,20 +137,13 @@ func TestMux_StreamClosing(t *testing.T) {
 	recvBuf := make([]byte, 128)
 	toBeClosed, _ := clientSession.OpenStream()
 	_, err := toBeClosed.Write(testData) // should be echoed back
-	if err != nil {
+	assert.NoError(t, err, "couldn't write to a stream")
-		t.Errorf("can't write to stream: %v", err)
-	}
 
 	_, err = io.ReadFull(toBeClosed, recvBuf[:1])
-	if err != nil {
+	assert.NoError(t, err, "can't read anything before stream closed")
-		t.Errorf("can't read anything before stream closed: %v", err)
+
-	}
 	_ = toBeClosed.Close()
 	_, err = io.ReadFull(toBeClosed, recvBuf[1:])
-	if err != nil {
+	assert.NoError(t, err, "can't read residual data on stream")
-		t.Errorf("can't read residual data on stream: %v", err)
+	assert.Equal(t, testData, recvBuf, "incorrect data read back")
-	}
-	if !bytes.Equal(testData, recvBuf) {
-		t.Errorf("incorrect data read back")
-	}
 }

internal/multiplex/streamBufferedPipe_test.go

@@ -1,7 +1,7 @@
 package multiplex
 
 import (
-	"bytes"
+	"github.com/stretchr/testify/assert"
 	"math/rand"
 	"testing"
 	"time"
@@ -13,49 +13,15 @@ func TestPipeRW(t *testing.T) {
 	pipe := NewStreamBufferedPipe()
 	b := []byte{0x01, 0x02, 0x03}
 	n, err := pipe.Write(b)
-	if n != len(b) {
+	assert.NoError(t, err, "simple write")
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes written")
-			"For", "number of bytes written",
-			"expecting", len(b),
-			"got", n,
-		)
-		return
-	}
-	if err != nil {
-		t.Error(
-			"For", "simple write",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
 
 	b2 := make([]byte, len(b))
 	n, err = pipe.Read(b2)
-	if n != len(b) {
+	assert.NoError(t, err, "simple read")
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes read")
-			"For", "number of bytes read",
-			"expecting", len(b),
-			"got", n,
-		)
-		return
-	}
-	if err != nil {
-		t.Error(
-			"For", "simple read",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b, b2) {
-		t.Error(
-			"For", "simple read",
-			"expecting", b,
-			"got", b2,
-		)
-	}
 
+	assert.Equal(t, b, b2)
 }
 
 func TestReadBlock(t *testing.T) {
@@ -67,30 +33,10 @@ func TestReadBlock(t *testing.T) {
 	}()
 	b2 := make([]byte, len(b))
 	n, err := pipe.Read(b2)
-	if n != len(b) {
+	assert.NoError(t, err, "blocked read")
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes read after block")
-			"For", "number of bytes read after block",
+
-			"expecting", len(b),
+	assert.Equal(t, b, b2)
-			"got", n,
-		)
-		return
-	}
-	if err != nil {
-		t.Error(
-			"For", "blocked read",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b, b2) {
-		t.Error(
-			"For", "blocked read",
-			"expecting", b,
-			"got", b2,
-		)
-		return
-	}
 }
 
 func TestPartialRead(t *testing.T) {
@@ -99,54 +45,17 @@ func TestPartialRead(t *testing.T) {
 	pipe.Write(b)
 	b1 := make([]byte, 1)
 	n, err := pipe.Read(b1)
-	if n != len(b1) {
+	assert.NoError(t, err, "partial read of 1")
-		t.Error(
+	assert.Equal(t, len(b1), n, "number of bytes in partial read of 1")
-			"For", "number of bytes in partial read of 1",
+
-			"expecting", len(b1),
+	assert.Equal(t, b[0], b1[0])
-			"got", n,
+
-		)
-		return
-	}
-	if err != nil {
-		t.Error(
-			"For", "partial read of 1",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if b1[0] != b[0] {
-		t.Error(
-			"For", "partial read of 1",
-			"expecting", b[0],
-			"got", b1[0],
-		)
-	}
 	b2 := make([]byte, 2)
 	n, err = pipe.Read(b2)
-	if n != len(b2) {
+	assert.NoError(t, err, "partial read of 2")
-		t.Error(
+	assert.Equal(t, len(b2), n, "number of bytes in partial read of 2")
-			"For", "number of bytes in partial read of 2",
+
-			"expecting", len(b2),
+	assert.Equal(t, b[1:], b2)
-			"got", n,
-		)
-	}
-	if err != nil {
-		t.Error(
-			"For", "partial read of 2",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b[1:], b2) {
-		t.Error(
-			"For", "partial read of 2",
-			"expecting", b[1:],
-			"got", b2,
-		)
-		return
-	}
 }
 
 func TestReadAfterClose(t *testing.T) {
@@ -156,29 +65,10 @@ func TestReadAfterClose(t *testing.T) {
 	b2 := make([]byte, len(b))
 	pipe.Close()
 	n, err := pipe.Read(b2)
-	if n != len(b) {
+	assert.NoError(t, err, "simple read")
-		t.Error(
+	assert.Equal(t, len(b), n, "number of bytes read")
-			"For", "number of bytes read",
+
-			"expecting", len(b),
+	assert.Equal(t, b, b2)
-			"got", n,
-		)
-	}
-	if err != nil {
-		t.Error(
-			"For", "simple read",
-			"expecting", "nil error",
-			"got", err,
-		)
-		return
-	}
-	if !bytes.Equal(b, b2) {
-		t.Error(
-			"For", "simple read",
-			"expecting", b,
-			"got", b2,
-		)
-		return
-	}
 }
 
 func BenchmarkBufferedPipe_RW(b *testing.B) {