From 9f8d68e09ae0fc3cf83e099e8333b3a4a58e7465 Mon Sep 17 00:00:00 2001 From: Daniel Adam Date: Fri, 1 Mar 2024 12:35:56 +0100 Subject: [PATCH 1/3] Update GitHub actions golangci/golangci-lint-action: v3 -> v4 --- .github/workflows/golangci-lint.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index 189215c1..2a6d4419 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -25,7 +25,7 @@ jobs: - run: go version - name: golangci-lint - uses: golangci/golangci-lint-action@v3 + uses: golangci/golangci-lint-action@v4 with: version: latest args: --timeout=5m From c6fa02dbf92ea7db479cad7a8610c9fc0a547a41 Mon Sep 17 00:00:00 2001 From: Daniel Adam Date: Fri, 1 Mar 2024 12:36:53 +0100 Subject: [PATCH 2/3] Upgrade dependencies Direct: github.com/stretchr/testify v1.9.0 golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 Indirect: golang.org/x/crypto v0.20.0 --- go.mod | 6 +++--- go.sum | 11 ++++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/go.mod b/go.mod index 3e5aad8e..4b358328 100644 --- a/go.mod +++ b/go.mod @@ -7,9 +7,9 @@ require ( github.com/hashicorp/go-multierror v1.1.1 github.com/pion/dtls/v2 v2.2.8-0.20240201071732-2597464081c8 github.com/pion/transport/v3 v3.0.1 - github.com/stretchr/testify v1.8.4 + github.com/stretchr/testify v1.9.0 go.uber.org/atomic v1.11.0 - golang.org/x/exp v0.0.0-20240213143201-ec583247a57a + golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 golang.org/x/net v0.21.0 golang.org/x/sync v0.6.0 ) @@ -19,7 +19,7 @@ require ( github.com/hashicorp/errwrap v1.1.0 // indirect github.com/pion/logging v0.2.2 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - golang.org/x/crypto v0.19.0 // indirect + golang.org/x/crypto v0.20.0 // indirect golang.org/x/sys v0.17.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index c6401fd0..473de4f6 100644 --- a/go.sum +++ b/go.sum @@ -21,8 +21,9 @@ github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSS github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= @@ -30,10 +31,10 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= -golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= -golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= -golang.org/x/exp v0.0.0-20240213143201-ec583247a57a h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE= -golang.org/x/exp v0.0.0-20240213143201-ec583247a57a/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc= +golang.org/x/crypto v0.20.0 h1:jmAMJJZXr5KiCw05dfYK9QnqaqKLYXijU23lsEdcQqg= +golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ= +golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 h1:LfspQV/FYTatPTr/3HzIcmiUFH7PGP+OQ6mgDYo3yuQ= +golang.org/x/exp v0.0.0-20240222234643-814bf88cf225/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= From 7f6233f7fff7d4da142d032115fc06361e68b2e4 Mon Sep 17 00:00:00 2001 From: Daniel Adam Date: Sun, 3 Mar 2024 12:08:43 +0100 Subject: [PATCH 3/3] SonarCloud: Add unit tests to increase code coverage --- options/commonOptions_test.go | 514 ++++++++++++++++++++++++++++++++++ options/tcpOptions_test.go | 45 +++ options/udpOptions_test.go | 64 +++++ pkg/rand/rand_test.go | 31 ++ 4 files changed, 654 insertions(+) create mode 100644 options/commonOptions_test.go create mode 100644 options/tcpOptions_test.go create mode 100644 options/udpOptions_test.go create mode 100644 pkg/rand/rand_test.go diff --git a/options/commonOptions_test.go b/options/commonOptions_test.go new file mode 100644 index 00000000..b894183a --- /dev/null +++ b/options/commonOptions_test.go @@ -0,0 +1,514 @@ +package options_test + +import ( + "context" + "net" + "testing" + "time" + + dtlsServer "github.com/plgd-dev/go-coap/v3/dtls/server" + "github.com/plgd-dev/go-coap/v3/message" + "github.com/plgd-dev/go-coap/v3/message/pool" + "github.com/plgd-dev/go-coap/v3/mux" + "github.com/plgd-dev/go-coap/v3/net/blockwise" + "github.com/plgd-dev/go-coap/v3/net/responsewriter" + "github.com/plgd-dev/go-coap/v3/options" + "github.com/plgd-dev/go-coap/v3/options/config" + "github.com/plgd-dev/go-coap/v3/pkg/runner/periodic" + "github.com/plgd-dev/go-coap/v3/tcp" + "github.com/plgd-dev/go-coap/v3/tcp/client" + "github.com/plgd-dev/go-coap/v3/tcp/server" + "github.com/plgd-dev/go-coap/v3/udp" + udpClient "github.com/plgd-dev/go-coap/v3/udp/client" + udpServer "github.com/plgd-dev/go-coap/v3/udp/server" + "github.com/stretchr/testify/require" +) + +func TestCommonTCPServerApply(t *testing.T) { + cfg := server.Config{} + handler := func(*responsewriter.ResponseWriter[*client.Conn], *pool.Message) { + // no-op + } + ctx := context.Background() + errs := func(error) { + // no-op + } + processRecvMessage := func(*pool.Message, *client.Conn, config.HandlerFunc[*client.Conn]) { + // no-op + } + inactivityMonitor := func(*client.Conn) { + // no-op + } + periodicRunner := periodic.New(ctx.Done(), time.Millisecond*10) + onNewConn := func(*client.Conn) { + // no-op + } + requestMonitor := func(*client.Conn, *pool.Message) (bool, error) { + return false, nil + } + mp := pool.New(1024, 1600) + getToken := func() (message.Token, error) { + return nil, nil + } + opts := []server.Option{ + options.WithHandlerFunc(handler), + options.WithContext(ctx), + options.WithMaxMessageSize(1024), + options.WithErrors(errs), + options.WithProcessReceivedMessageFunc(processRecvMessage), + options.WithInactivityMonitor(time.Minute, inactivityMonitor), + options.WithPeriodicRunner(periodicRunner), + options.WithBlockwise(true, blockwise.SZX16, time.Second), + options.WithOnNewConn(onNewConn), + options.WithRequestMonitor(requestMonitor), + options.WithMessagePool(mp), + options.WithGetToken(getToken), + options.WithLimitClientParallelRequest(42), + options.WithLimitClientEndpointParallelRequest(43), + options.WithReceivedMessageQueueSize(10), + } + + for _, o := range opts { + o.TCPServerApply(&cfg) + } + // WithHandlerFunc + require.NotNil(t, cfg.Handler) + // WithContext + require.Equal(t, ctx, cfg.Ctx) + // WithMaxMessageSize + require.Equal(t, uint32(1024), cfg.MaxMessageSize) + // WithErrors + require.NotNil(t, cfg.Errors) + // WithProcessReceivedMessageFunc + require.NotNil(t, cfg.ProcessReceivedMessage) + // WithInactivityMonitor + require.NotNil(t, cfg.CreateInactivityMonitor) + // WithPeriodicRunner + require.NotNil(t, cfg.PeriodicRunner) + // WithBlockwise + require.True(t, cfg.BlockwiseEnable) + require.Equal(t, blockwise.SZX16, cfg.BlockwiseSZX) + require.Equal(t, time.Second, cfg.BlockwiseTransferTimeout) + // WithOnNewConn + require.NotNil(t, cfg.OnNewConn) + // WithRequestMonitor + require.NotNil(t, cfg.RequestMonitor) + // WithMessagePool + require.Equal(t, mp, cfg.MessagePool) + // WithGetToken + require.NotNil(t, cfg.GetToken) + // WithLimitClientParallelRequest + require.Equal(t, int64(42), cfg.LimitClientParallelRequests) + // WithLimitClientEndpointParallelRequest + require.Equal(t, int64(43), cfg.LimitClientEndpointParallelRequests) + // WithReceivedMessageQueueSize + require.Equal(t, 10, cfg.ReceivedMessageQueueSize) + + m := mux.NewRouter() + keepAlive := func(*client.Conn) { + // no-op + } + cfg = server.Config{} + opts = []server.Option{ + options.WithMux(m), + options.WithKeepAlive(16, time.Second, keepAlive), + } + for _, o := range opts { + o.TCPServerApply(&cfg) + } + // WithMux + require.NotNil(t, cfg.Handler) + // WithKeepAlive + require.NotNil(t, cfg.CreateInactivityMonitor) +} + +func TestCommonTCPClientApply(t *testing.T) { + cfg := client.Config{} + handler := func(*responsewriter.ResponseWriter[*client.Conn], *pool.Message) { + // no-op + } + ctx := context.Background() + errs := func(error) { + // no-op + } + processRecvMessage := func(*pool.Message, *client.Conn, config.HandlerFunc[*client.Conn]) { + // no-op + } + inactivityMonitor := func(*client.Conn) { + // no-op + } + network := "tcp" + periodicRunner := periodic.New(ctx.Done(), time.Millisecond*10) + dialer := &net.Dialer{Timeout: time.Second * 3} + mp := pool.New(1024, 1600) + getToken := func() (message.Token, error) { + return nil, nil + } + opts := []tcp.Option{ + options.WithHandlerFunc(handler), + options.WithContext(ctx), + options.WithMaxMessageSize(1024), + options.WithErrors(errs), + options.WithProcessReceivedMessageFunc(processRecvMessage), + options.WithInactivityMonitor(time.Minute, inactivityMonitor), + options.WithNetwork(network), + options.WithPeriodicRunner(periodicRunner), + options.WithBlockwise(true, blockwise.SZX16, time.Second), + options.WithCloseSocket(), + options.WithDialer(dialer), + options.WithMessagePool(mp), + options.WithGetToken(getToken), + options.WithLimitClientParallelRequest(42), + options.WithLimitClientEndpointParallelRequest(43), + options.WithReceivedMessageQueueSize(10), + } + + for _, o := range opts { + o.TCPClientApply(&cfg) + } + // WithHandlerFunc + require.NotNil(t, cfg.Handler) + // WithContext + require.Equal(t, ctx, cfg.Ctx) + // WithMaxMessageSize + require.Equal(t, uint32(1024), cfg.MaxMessageSize) + // WithErrors + require.NotNil(t, cfg.Errors) + // WithProcessReceivedMessageFunc + require.NotNil(t, cfg.ProcessReceivedMessage) + // WithInactivityMonitor + require.NotNil(t, cfg.CreateInactivityMonitor) + // WithNetwork + require.Equal(t, network, cfg.Net) + // WithPeriodicRunner + require.NotNil(t, cfg.PeriodicRunner) + // WithBlockwise + require.True(t, cfg.BlockwiseEnable) + require.Equal(t, blockwise.SZX16, cfg.BlockwiseSZX) + require.Equal(t, time.Second, cfg.BlockwiseTransferTimeout) + // WithCloseSocket + require.True(t, cfg.CloseSocket) + // WithDialer + require.Equal(t, dialer, cfg.Dialer) + // WithMessagePool + require.Equal(t, mp, cfg.MessagePool) + // WithGetToken + require.NotNil(t, cfg.GetToken) + // WithLimitClientParallelRequest + require.Equal(t, int64(42), cfg.LimitClientParallelRequests) + // WithLimitClientEndpointParallelRequest + require.Equal(t, int64(43), cfg.LimitClientEndpointParallelRequests) + // WithReceivedMessageQueueSize + require.Equal(t, 10, cfg.ReceivedMessageQueueSize) + + m := mux.NewRouter() + keepAlive := func(*client.Conn) { + // no-op + } + cfg = client.Config{} + opts = []tcp.Option{ + options.WithMux(m), + options.WithKeepAlive(16, time.Second, keepAlive), + } + for _, o := range opts { + o.TCPClientApply(&cfg) + } + // WithMux + require.NotNil(t, cfg.Handler) + // WithKeepAlive + require.NotNil(t, cfg.CreateInactivityMonitor) +} + +func TestCommonUDPServerApply(t *testing.T) { + cfg := udpServer.Config{} + handler := func(*responsewriter.ResponseWriter[*udpClient.Conn], *pool.Message) { + // no-op + } + ctx := context.Background() + errs := func(error) { + // no-op + } + processRecvMessage := func(*pool.Message, *udpClient.Conn, config.HandlerFunc[*udpClient.Conn]) { + // no-op + } + inactivityMonitor := func(*udpClient.Conn) { + // no-op + } + periodicRunner := periodic.New(ctx.Done(), time.Millisecond*10) + onNewConn := func(*udpClient.Conn) { + // no-op + } + requestMonitor := func(*udpClient.Conn, *pool.Message) (bool, error) { + return false, nil + } + mp := pool.New(1024, 1600) + getToken := func() (message.Token, error) { + return nil, nil + } + opts := []udpServer.Option{ + options.WithHandlerFunc(handler), + options.WithContext(ctx), + options.WithMaxMessageSize(1024), + options.WithErrors(errs), + options.WithProcessReceivedMessageFunc(processRecvMessage), + options.WithInactivityMonitor(time.Minute, inactivityMonitor), + options.WithPeriodicRunner(periodicRunner), + options.WithBlockwise(true, blockwise.SZX16, time.Second), + options.WithOnNewConn(onNewConn), + options.WithRequestMonitor(requestMonitor), + options.WithMessagePool(mp), + options.WithGetToken(getToken), + options.WithLimitClientParallelRequest(42), + options.WithLimitClientEndpointParallelRequest(43), + options.WithReceivedMessageQueueSize(10), + } + + for _, o := range opts { + o.UDPServerApply(&cfg) + } + // WithHandlerFunc + require.NotNil(t, cfg.Handler) + // WithContext + require.Equal(t, ctx, cfg.Ctx) + // WithMaxMessageSize + require.Equal(t, uint32(1024), cfg.MaxMessageSize) + // WithErrors + require.NotNil(t, cfg.Errors) + // WithProcessReceivedMessageFunc + require.NotNil(t, cfg.ProcessReceivedMessage) + // WithInactivityMonitor + require.NotNil(t, cfg.CreateInactivityMonitor) + // WithPeriodicRunner + require.NotNil(t, cfg.PeriodicRunner) + // WithBlockwise + require.True(t, cfg.BlockwiseEnable) + require.Equal(t, blockwise.SZX16, cfg.BlockwiseSZX) + require.Equal(t, time.Second, cfg.BlockwiseTransferTimeout) + // WithOnNewConn + require.NotNil(t, cfg.OnNewConn) + // WithRequestMonitor + require.NotNil(t, cfg.RequestMonitor) + // WithMessagePool + require.Equal(t, mp, cfg.MessagePool) + // WithGetToken + require.NotNil(t, cfg.GetToken) + // WithLimitClientParallelRequest + require.Equal(t, int64(42), cfg.LimitClientParallelRequests) + // WithLimitClientEndpointParallelRequest + require.Equal(t, int64(43), cfg.LimitClientEndpointParallelRequests) + // WithReceivedMessageQueueSize + require.Equal(t, 10, cfg.ReceivedMessageQueueSize) + + m := mux.NewRouter() + keepAlive := func(*udpClient.Conn) { + // no-op + } + cfg = udpServer.Config{} + opts = []udpServer.Option{ + options.WithMux(m), + options.WithKeepAlive(16, time.Second, keepAlive), + } + for _, o := range opts { + o.UDPServerApply(&cfg) + } + // WithMux + require.NotNil(t, cfg.Handler) + // WithKeepAlive + require.NotNil(t, cfg.CreateInactivityMonitor) +} + +func TestCommonDTLSServerApply(t *testing.T) { + cfg := dtlsServer.Config{} + handler := func(*responsewriter.ResponseWriter[*udpClient.Conn], *pool.Message) { + // no-op + } + ctx := context.Background() + errs := func(error) { + // no-op + } + processRecvMessage := func(*pool.Message, *udpClient.Conn, config.HandlerFunc[*udpClient.Conn]) { + // no-op + } + inactivityMonitor := func(*udpClient.Conn) { + // no-op + } + periodicRunner := periodic.New(ctx.Done(), time.Millisecond*10) + onNewConn := func(*udpClient.Conn) { + // no-op + } + requestMonitor := func(*udpClient.Conn, *pool.Message) (bool, error) { + return false, nil + } + mp := pool.New(1024, 1600) + getToken := func() (message.Token, error) { + return nil, nil + } + opts := []dtlsServer.Option{ + options.WithHandlerFunc(handler), + options.WithContext(ctx), + options.WithMaxMessageSize(1024), + options.WithErrors(errs), + options.WithProcessReceivedMessageFunc(processRecvMessage), + options.WithInactivityMonitor(time.Minute, inactivityMonitor), + options.WithPeriodicRunner(periodicRunner), + options.WithBlockwise(true, blockwise.SZX16, time.Second), + options.WithOnNewConn(onNewConn), + options.WithRequestMonitor(requestMonitor), + options.WithMessagePool(mp), + options.WithGetToken(getToken), + options.WithLimitClientParallelRequest(42), + options.WithLimitClientEndpointParallelRequest(43), + options.WithReceivedMessageQueueSize(10), + } + + for _, o := range opts { + o.DTLSServerApply(&cfg) + } + // WithHandlerFunc + require.NotNil(t, cfg.Handler) + // WithContext + require.Equal(t, ctx, cfg.Ctx) + // WithMaxMessageSize + require.Equal(t, uint32(1024), cfg.MaxMessageSize) + // WithErrors + require.NotNil(t, cfg.Errors) + // WithProcessReceivedMessageFunc + require.NotNil(t, cfg.ProcessReceivedMessage) + // WithInactivityMonitor + require.NotNil(t, cfg.CreateInactivityMonitor) + // WithPeriodicRunner + require.NotNil(t, cfg.PeriodicRunner) + // WithBlockwise + require.True(t, cfg.BlockwiseEnable) + require.Equal(t, blockwise.SZX16, cfg.BlockwiseSZX) + require.Equal(t, time.Second, cfg.BlockwiseTransferTimeout) + // WithOnNewConn + require.NotNil(t, cfg.OnNewConn) + // WithRequestMonitor + require.NotNil(t, cfg.RequestMonitor) + // WithMessagePool + require.Equal(t, mp, cfg.MessagePool) + // WithGetToken + require.NotNil(t, cfg.GetToken) + // WithLimitClientParallelRequest + require.Equal(t, int64(42), cfg.LimitClientParallelRequests) + // WithLimitClientEndpointParallelRequest + require.Equal(t, int64(43), cfg.LimitClientEndpointParallelRequests) + // WithReceivedMessageQueueSize + require.Equal(t, 10, cfg.ReceivedMessageQueueSize) + + m := mux.NewRouter() + keepAlive := func(*udpClient.Conn) { + // no-op + } + cfg = dtlsServer.Config{} + opts = []dtlsServer.Option{ + options.WithMux(m), + options.WithKeepAlive(16, time.Second, keepAlive), + } + for _, o := range opts { + o.DTLSServerApply(&cfg) + } + // WithMux + require.NotNil(t, cfg.Handler) + // WithKeepAlive + require.NotNil(t, cfg.CreateInactivityMonitor) +} + +func TestCommonUDPClientApply(t *testing.T) { + cfg := udpClient.Config{} + handler := func(*responsewriter.ResponseWriter[*udpClient.Conn], *pool.Message) { + // no-op + } + ctx := context.Background() + errs := func(error) { + // no-op + } + processRecvMessage := func(*pool.Message, *udpClient.Conn, config.HandlerFunc[*udpClient.Conn]) { + // no-op + } + inactivityMonitor := func(*udpClient.Conn) { + // no-op + } + network := "udp4" + periodicRunner := periodic.New(ctx.Done(), time.Millisecond*10) + dialer := &net.Dialer{Timeout: time.Second * 3} + + mp := pool.New(1024, 1600) + getToken := func() (message.Token, error) { + return nil, nil + } + opts := []udp.Option{ + options.WithHandlerFunc(handler), + options.WithContext(ctx), + options.WithMaxMessageSize(1024), + options.WithErrors(errs), + options.WithProcessReceivedMessageFunc(processRecvMessage), + options.WithInactivityMonitor(time.Minute, inactivityMonitor), + options.WithNetwork(network), + options.WithPeriodicRunner(periodicRunner), + options.WithBlockwise(true, blockwise.SZX16, time.Second), + options.WithCloseSocket(), + options.WithDialer(dialer), + options.WithMessagePool(mp), + options.WithGetToken(getToken), + options.WithLimitClientParallelRequest(42), + options.WithLimitClientEndpointParallelRequest(43), + options.WithReceivedMessageQueueSize(10), + } + + for _, o := range opts { + o.UDPClientApply(&cfg) + } + // WithHandlerFunc + require.NotNil(t, cfg.Handler) + // WithContext + require.Equal(t, ctx, cfg.Ctx) + // WithMaxMessageSize + require.Equal(t, uint32(1024), cfg.MaxMessageSize) + // WithErrors + require.NotNil(t, cfg.Errors) + // WithProcessReceivedMessageFunc + require.NotNil(t, cfg.ProcessReceivedMessage) + // WithInactivityMonitor + require.NotNil(t, cfg.CreateInactivityMonitor) + // WithNetwork + require.Equal(t, network, cfg.Net) + // WithPeriodicRunner + require.NotNil(t, cfg.PeriodicRunner) + // WithBlockwise + require.True(t, cfg.BlockwiseEnable) + require.Equal(t, blockwise.SZX16, cfg.BlockwiseSZX) + require.Equal(t, time.Second, cfg.BlockwiseTransferTimeout) + // WithCloseSocket + require.True(t, cfg.CloseSocket) + // WithDialer + require.Equal(t, dialer, cfg.Dialer) + // WithMessagePool + require.Equal(t, mp, cfg.MessagePool) + // WithGetToken + require.NotNil(t, cfg.GetToken) + // WithLimitClientParallelRequest + require.Equal(t, int64(42), cfg.LimitClientParallelRequests) + // WithLimitClientEndpointParallelRequest + require.Equal(t, int64(43), cfg.LimitClientEndpointParallelRequests) + // WithReceivedMessageQueueSize + require.Equal(t, 10, cfg.ReceivedMessageQueueSize) + + m := mux.NewRouter() + keepAlive := func(*udpClient.Conn) { + // no-op + } + cfg = udpClient.Config{} + opts = []udp.Option{ + options.WithMux(m), + options.WithKeepAlive(16, time.Second, keepAlive), + } + for _, o := range opts { + o.UDPClientApply(&cfg) + } + // WithMux + require.NotNil(t, cfg.Handler) + // WithKeepAlive + require.NotNil(t, cfg.CreateInactivityMonitor) +} diff --git a/options/tcpOptions_test.go b/options/tcpOptions_test.go new file mode 100644 index 00000000..65fa0fe6 --- /dev/null +++ b/options/tcpOptions_test.go @@ -0,0 +1,45 @@ +package options_test + +import ( + "crypto/tls" + "testing" + + "github.com/plgd-dev/go-coap/v3/options" + "github.com/plgd-dev/go-coap/v3/tcp" + "github.com/plgd-dev/go-coap/v3/tcp/client" + "github.com/plgd-dev/go-coap/v3/tcp/server" + "github.com/stretchr/testify/require" +) + +func TestTCPClientApply(t *testing.T) { + cfg := client.Config{} + tlsCfg := &tls.Config{} + opt := []tcp.Option{ + options.WithDisablePeerTCPSignalMessageCSMs(), + options.WithDisableTCPSignalMessageCSM(), + options.WithTLS(tlsCfg), + options.WithConnectionCacheSize(100), + } + for _, o := range opt { + o.TCPClientApply(&cfg) + } + require.True(t, cfg.DisablePeerTCPSignalMessageCSMs) + require.True(t, cfg.DisableTCPSignalMessageCSM) + require.Equal(t, tlsCfg, cfg.TLSCfg) + require.Equal(t, uint16(100), cfg.ConnectionCacheSize) +} + +func TestTCPServerApply(t *testing.T) { + cfg := server.Config{} + opt := []server.Option{ + options.WithDisablePeerTCPSignalMessageCSMs(), + options.WithDisableTCPSignalMessageCSM(), + options.WithConnectionCacheSize(100), + } + for _, o := range opt { + o.TCPServerApply(&cfg) + } + require.True(t, cfg.DisablePeerTCPSignalMessageCSMs) + require.True(t, cfg.DisableTCPSignalMessageCSM) + require.Equal(t, uint16(100), cfg.ConnectionCacheSize) +} diff --git a/options/udpOptions_test.go b/options/udpOptions_test.go new file mode 100644 index 00000000..56dd12c9 --- /dev/null +++ b/options/udpOptions_test.go @@ -0,0 +1,64 @@ +package options_test + +import ( + "testing" + "time" + + dtlsServer "github.com/plgd-dev/go-coap/v3/dtls/server" + "github.com/plgd-dev/go-coap/v3/options" + "github.com/plgd-dev/go-coap/v3/udp" + "github.com/plgd-dev/go-coap/v3/udp/client" + udpServer "github.com/plgd-dev/go-coap/v3/udp/server" + "github.com/stretchr/testify/require" +) + +func TestUDPServerApply(t *testing.T) { + cfg := udpServer.Config{} + opt := []udpServer.Option{ + options.WithTransmission(10, time.Second, 5), + options.WithMTU(1500), + } + for _, o := range opt { + o.UDPServerApply(&cfg) + } + // WithTransmission + require.Equal(t, uint32(10), cfg.TransmissionNStart) + require.Equal(t, time.Second, cfg.TransmissionAcknowledgeTimeout) + require.Equal(t, uint32(5), cfg.TransmissionMaxRetransmit) + // WithMTU + require.Equal(t, uint16(1500), cfg.MTU) +} + +func TestDTLSServerApply(t *testing.T) { + cfg := dtlsServer.Config{} + opt := []dtlsServer.Option{ + options.WithTransmission(10, time.Second, 5), + options.WithMTU(1500), + } + for _, o := range opt { + o.DTLSServerApply(&cfg) + } + // WithTransmission + require.Equal(t, uint32(10), cfg.TransmissionNStart) + require.Equal(t, time.Second, cfg.TransmissionAcknowledgeTimeout) + require.Equal(t, uint32(5), cfg.TransmissionMaxRetransmit) + // WithMTU + require.Equal(t, uint16(1500), cfg.MTU) +} + +func TestUDPClientApply(t *testing.T) { + cfg := client.Config{} + opt := []udp.Option{ + options.WithTransmission(10, time.Second, 5), + options.WithMTU(1500), + } + for _, o := range opt { + o.UDPClientApply(&cfg) + } + // WithTransmission + require.Equal(t, uint32(10), cfg.TransmissionNStart) + require.Equal(t, time.Second, cfg.TransmissionAcknowledgeTimeout) + require.Equal(t, uint32(5), cfg.TransmissionMaxRetransmit) + // WithMTU + require.Equal(t, uint16(1500), cfg.MTU) +} diff --git a/pkg/rand/rand_test.go b/pkg/rand/rand_test.go new file mode 100644 index 00000000..e7812fa7 --- /dev/null +++ b/pkg/rand/rand_test.go @@ -0,0 +1,31 @@ +package rand_test + +import ( + "sync" + "testing" + + "github.com/plgd-dev/go-coap/v3/pkg/rand" +) + +func TestRand(*testing.T) { + r := rand.NewRand(0) + _ = r.Int63() + _ = r.Uint32() +} + +func TestMultiThreadedRand(*testing.T) { + r := rand.NewRand(0) + var done sync.WaitGroup + for i := 0; i < 100; i++ { + done.Add(1) + go func(index int) { + if index%2 == 0 { + _ = r.Int63() + } else { + _ = r.Uint32() + } + done.Done() + }(i) + } + done.Wait() +}