diff --git a/cmd/ck-server/ck-server_test.go b/cmd/ck-server/ck-server_test.go index 09de559..87427ee 100644 --- a/cmd/ck-server/ck-server_test.go +++ b/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 { - t.Error(err) - return - } - if addrs[0].String() != ":443" { - t.Errorf("expected %v got %v", ":443", addrs[0].String()) - } + assert.NoError(t, err) + assert.Equal(t, ":443", addrs[0].String()) }) t.Run("specific address", func(t *testing.T) { addrs, err := resolveBindAddr([]string{"192.168.1.123:443"}) - if err != nil { - t.Error(err) - return - } - if addrs[0].String() != "192.168.1.123:443" { - t.Errorf("expected %v got %v", "192.168.1.123:443", addrs[0].String()) - } + assert.NoError(t, err) + assert.Equal(t, "192.168.1.123:443", addrs[0].String()) }) t.Run("ipv6", func(t *testing.T) { addrs, err := resolveBindAddr([]string{"[::]:443"}) - if err != nil { - t.Error(err) - return - } - if addrs[0].String() != "[::]:443" { - t.Errorf("expected %v got %v", "[::]:443", addrs[0].String()) - } + assert.NoError(t, err) + assert.Equal(t, "[::]:443", addrs[0].String()) }) t.Run("mixed", func(t *testing.T) { addrs, err := resolveBindAddr([]string{":80", "[::]:443"}) - if err != nil { - t.Error(err) - return - } - 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()) - } + assert.NoError(t, err) + assert.Equal(t, ":80", addrs[0].String()) + assert.Equal(t, "[::]:443", addrs[1].String()) }) } diff --git a/internal/client/TLS_test.go b/internal/client/TLS_test.go index 9093e8a..b8bdd81 100644 --- a/internal/client/TLS_test.go +++ b/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) { - t.Error( - "for", p.serverName, - "expecting", p.target, - "got", makeServerName(p.serverName)) - } + assert.Equal(t, p.target, makeServerName(p.serverName)) } } diff --git a/internal/client/auth_test.go b/internal/client/auth_test.go index eda0c2c..4c7da33 100644 --- a/internal/client/auth_test.go +++ b/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 { - t.Errorf("payload doesn't match:\nexp %v\ngot %v", tc.expPayload, payload) - } - if sharedSecret != tc.expSecret { - t.Errorf("secret doesn't match:\nexp %x\ngot %x", tc.expPayload, payload) - } + assert.Equal(t, tc.expPayload, payload, "payload doesn't match") + assert.Equal(t, tc.expSecret, sharedSecret, "shared secret doesn't match") }() } } diff --git a/internal/multiplex/datagramBufferedPipe_test.go b/internal/multiplex/datagramBufferedPipe_test.go index 6b20f76..8d7a07b 100644 --- a/internal/multiplex/datagramBufferedPipe_test.go +++ b/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 { - t.Error( - "expecting", "nil error", - "got", err, - ) - return - } + assert.NoError(t, err) }) 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) { - t.Error( - "For", "number of bytes read", - "expecting", len(b), - "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 - } - + assert.NoError(t, err) + assert.Equal(t, len(b), n) + assert.Equal(t, b, b2) + assert.Equal(t, 0, pipe.buf.Len(), "buf len is not 0 after finished reading") }) t.Run("writing closing frame", func(t *testing.T) { pipe := NewDatagramBufferedPipe() toBeClosed, err := pipe.Write(&Frame{Closing: closingStream}) - if !toBeClosed { - t.Error("should be to be closed") - } - if err != nil { - t.Error( - "expecting", "nil error", - "got", err, - ) - return - } - if !pipe.closed { - t.Error("expecting closed pipe, not closed") - } + assert.NoError(t, err) + assert.True(t, toBeClosed, "should be to be closed") + assert.True(t, pipe.closed, "pipe should be 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) { - t.Error( - "For", "number of bytes read after block", - "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 - } + assert.NoError(t, err) + assert.Equal(t, len(b), n, "number of bytes read after block is wrong") + assert.Equal(t, b, b2) } 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) { - t.Error( - "For", "number of bytes read", - "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 - } + assert.NoError(t, err) + assert.Equal(t, len(b), n, "number of bytes read after block is wrong") + assert.Equal(t, b, b2) } diff --git a/internal/multiplex/mux_test.go b/internal/multiplex/mux_test.go index e492305..6bb57ed 100644 --- a/internal/multiplex/mux_test.go +++ b/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 { - t.Fatalf("failed to open stream: %v", err) - } + assert.NoError(t, 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 { - t.Errorf("couldn't close a stream") - } + assert.NoError(t, err, "couldn't close a stream") _, err = closing.Write([]byte{0}) - if err != ErrBrokenStream { - t.Errorf("expecting error %v, got %v", ErrBrokenStream, err) - } + assert.Equal(t, ErrBrokenStream, err) _, err = closing.Read(make([]byte, 1)) - if err != ErrBrokenStream { - t.Errorf("expecting error %v, got %v", ErrBrokenStream, err) - } - + assert.Equal(t, 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 { - t.Errorf("can't write to stream: %v", err) - } + assert.NoError(t, err, "couldn't write to a stream") _, err = io.ReadFull(toBeClosed, recvBuf[:1]) - if err != nil { - t.Errorf("can't read anything before stream closed: %v", err) - } + assert.NoError(t, err, "can't read anything before stream closed") + _ = toBeClosed.Close() _, err = io.ReadFull(toBeClosed, recvBuf[1:]) - if err != nil { - t.Errorf("can't read residual data on stream: %v", err) - } - if !bytes.Equal(testData, recvBuf) { - t.Errorf("incorrect data read back") - } + assert.NoError(t, err, "can't read residual data on stream") + assert.Equal(t, testData, recvBuf, "incorrect data read back") } diff --git a/internal/multiplex/streamBufferedPipe_test.go b/internal/multiplex/streamBufferedPipe_test.go index ff0ec24..6cdbff1 100644 --- a/internal/multiplex/streamBufferedPipe_test.go +++ b/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) { - t.Error( - "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 - } + assert.NoError(t, err, "simple write") + assert.Equal(t, len(b), n, "number of bytes written") b2 := make([]byte, len(b)) n, err = pipe.Read(b2) - if n != len(b) { - t.Error( - "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.NoError(t, err, "simple read") + assert.Equal(t, len(b), n, "number of bytes read") + 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) { - t.Error( - "For", "number of bytes read after block", - "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 - } + assert.NoError(t, err, "blocked read") + assert.Equal(t, len(b), n, "number of bytes read after block") + + assert.Equal(t, b, b2) } 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) { - t.Error( - "For", "number of bytes in partial read of 1", - "expecting", len(b1), - "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], - ) - } + assert.NoError(t, err, "partial read of 1") + assert.Equal(t, len(b1), n, "number of bytes in partial read of 1") + + assert.Equal(t, b[0], b1[0]) + b2 := make([]byte, 2) n, err = pipe.Read(b2) - if n != len(b2) { - t.Error( - "For", "number of bytes in partial read of 2", - "expecting", len(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 - } + assert.NoError(t, err, "partial read of 2") + assert.Equal(t, len(b2), n, "number of bytes in partial read of 2") + + assert.Equal(t, b[1:], b2) } 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) { - t.Error( - "For", "number of bytes read", - "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 - } + assert.NoError(t, err, "simple read") + assert.Equal(t, len(b), n, "number of bytes read") + + assert.Equal(t, b, b2) } func BenchmarkBufferedPipe_RW(b *testing.B) {