You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2023/05/09 14:41:36 UTC
[plc4x] branch develop updated (1fedb943cb -> 3a5ccfac1b)
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a change to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
from 1fedb943cb build(deps): bump golang.org/x/tools from 0.8.0 to 0.9.0 in /plc4go (#935)
new c889e477b8 test(plc4go/spi): replace temp mock with mockery mock in write buffer
new 3a5ccfac1b test(plc4go/spi): replace temp mocks with mockery mock
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
plc4go/internal/bacnetip/Connection.go | 4 +-
plc4go/internal/cbus/Discoverer_test.go | 2 +-
plc4go/internal/cbus/Writer_test.go | 4 +-
plc4go/spi/default/DefaultBrowser.go | 6 +
plc4go/spi/default/DefaultBrowser_test.go | 27 ++--
plc4go/spi/default/DefaultCodec.go | 2 +-
plc4go/spi/default/DefaultCodec_test.go | 157 ++++++++++++---------
plc4go/spi/default/DefaultConnection_test.go | 123 ++++++++++++----
plc4go/spi/default/DefaultDriver_test.go | 77 ++++++----
plc4go/spi/{ => default}/mock_MessageCodec_test.go | 109 ++++++++++----
plc4go/spi/{ => default}/mock_Message_test.go | 2 +-
.../mock_PlcConnectionConnectResult_test.go | 19 +--
.../api => spi/default}/mock_PlcConnection_test.go | 52 +++----
.../model => spi/default}/mock_PlcQuery_test.go | 2 +-
.../spi/{ => default}/mock_PlcTagHandler_test.go | 2 +-
.../mock_TransportInstance_test.go | 2 +-
.../{testDriver_test.go => mock_requirements.go} | 43 ++++--
plc4go/spi/default/testBrowser_test.go | 39 -----
plc4go/spi/default/testConnection_test.go | 99 -------------
plc4go/spi/default/testMessageCodec_test.go | 93 ------------
plc4go/spi/default/testMessage_test.go | 49 -------
plc4go/spi/default/testQuery_test.go | 28 ----
plc4go/spi/default/testTagHandler_test.go | 34 -----
plc4go/spi/transports/TransportInstance.go | 2 +-
plc4go/spi/utils/Net.go | 6 +-
plc4go/spi/utils/WriteBufferByteBased_test.go | 18 +--
26 files changed, 436 insertions(+), 565 deletions(-)
copy plc4go/spi/{ => default}/mock_MessageCodec_test.go (73%)
copy plc4go/spi/{ => default}/mock_Message_test.go (99%)
copy plc4go/{pkg/api => spi/default}/mock_PlcConnectionConnectResult_test.go (88%)
copy plc4go/{pkg/api => spi/default}/mock_PlcConnection_test.go (89%)
copy plc4go/{pkg/api/model => spi/default}/mock_PlcQuery_test.go (99%)
copy plc4go/spi/{ => default}/mock_PlcTagHandler_test.go (99%)
copy plc4go/spi/{transports => default}/mock_TransportInstance_test.go (99%)
rename plc4go/spi/default/{testDriver_test.go => mock_requirements.go} (53%)
delete mode 100644 plc4go/spi/default/testBrowser_test.go
delete mode 100644 plc4go/spi/default/testConnection_test.go
delete mode 100644 plc4go/spi/default/testMessageCodec_test.go
delete mode 100644 plc4go/spi/default/testMessage_test.go
delete mode 100644 plc4go/spi/default/testQuery_test.go
delete mode 100644 plc4go/spi/default/testTagHandler_test.go
[plc4x] 02/02: test(plc4go/spi): replace temp mocks with mockery mock
Posted by sr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 3a5ccfac1b3c793aca8b766f185cf8e4c9243c17
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue May 9 15:37:08 2023 +0200
test(plc4go/spi): replace temp mocks with mockery mock
---
plc4go/internal/bacnetip/Connection.go | 4 +-
plc4go/internal/cbus/Discoverer_test.go | 2 +-
plc4go/internal/cbus/Writer_test.go | 4 +-
plc4go/spi/default/DefaultBrowser.go | 6 +
plc4go/spi/default/DefaultBrowser_test.go | 27 +-
plc4go/spi/default/DefaultCodec.go | 2 +-
plc4go/spi/default/DefaultCodec_test.go | 157 +++---
plc4go/spi/default/DefaultConnection_test.go | 123 ++++-
plc4go/spi/default/DefaultDriver_test.go | 77 ++-
plc4go/spi/default/mock_MessageCodec_test.go | 447 ++++++++++++++++
plc4go/spi/default/mock_Message_test.go | 237 +++++++++
.../mock_PlcConnectionConnectResult_test.go | 139 +++++
plc4go/spi/default/mock_PlcConnection_test.go | 563 +++++++++++++++++++++
plc4go/spi/default/mock_PlcQuery_test.go | 93 ++++
plc4go/spi/default/mock_PlcTagHandler_test.go | 163 ++++++
plc4go/spi/default/mock_TransportInstance_test.go | 506 ++++++++++++++++++
.../{testDriver_test.go => mock_requirements.go} | 43 +-
plc4go/spi/default/testBrowser_test.go | 39 --
plc4go/spi/default/testConnection_test.go | 99 ----
plc4go/spi/default/testMessageCodec_test.go | 93 ----
plc4go/spi/default/testMessage_test.go | 49 --
plc4go/spi/default/testQuery_test.go | 28 -
plc4go/spi/default/testTagHandler_test.go | 34 --
plc4go/spi/transports/TransportInstance.go | 2 +-
plc4go/spi/utils/Net.go | 6 +-
25 files changed, 2458 insertions(+), 485 deletions(-)
diff --git a/plc4go/internal/bacnetip/Connection.go b/plc4go/internal/bacnetip/Connection.go
index 7354d61fe3..0258615506 100644
--- a/plc4go/internal/bacnetip/Connection.go
+++ b/plc4go/internal/bacnetip/Connection.go
@@ -22,6 +22,7 @@ package bacnetip
import (
"context"
"fmt"
+ "github.com/apache/plc4x/plc4go/spi/utils"
"sync"
"time"
@@ -30,7 +31,6 @@ import (
"github.com/apache/plc4x/plc4go/spi"
"github.com/apache/plc4x/plc4go/spi/default"
internalModel "github.com/apache/plc4x/plc4go/spi/model"
- "github.com/apache/plc4x/plc4go/spi/utils"
"github.com/rs/zerolog/log"
)
@@ -85,11 +85,11 @@ func (c *Connection) ConnectWithContext(ctx context.Context) <-chan plc4go.PlcCo
log.Trace().Msg("Polling data")
incomingMessageChannel := c.messageCodec.GetDefaultIncomingMessageChannel()
timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
select {
case message := <-incomingMessageChannel:
// TODO: implement mapping to subscribers
log.Info().Msgf("Received \n%v", message)
- utils.CleanupTimer(timeout)
case <-timeout.C:
}
}
diff --git a/plc4go/internal/cbus/Discoverer_test.go b/plc4go/internal/cbus/Discoverer_test.go
index 2e6ecffac5..8c7949d1fc 100644
--- a/plc4go/internal/cbus/Discoverer_test.go
+++ b/plc4go/internal/cbus/Discoverer_test.go
@@ -290,7 +290,7 @@ func TestDiscoverer_createTransportInstanceDispatcher(t *testing.T) {
assert.NotNilf(t, dispatcher, "createTransportInstanceDispatcher(%v, %v, %v, %v, %v)", tt.args.ctx, tt.args.wg, tt.args.ip, tt.args.tcpTransport, tt.args.transportInstances)
dispatcher()
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case <-timeout.C:
t.Error("timeout")
diff --git a/plc4go/internal/cbus/Writer_test.go b/plc4go/internal/cbus/Writer_test.go
index 4f592912fd..b1ba9db6cf 100644
--- a/plc4go/internal/cbus/Writer_test.go
+++ b/plc4go/internal/cbus/Writer_test.go
@@ -82,7 +82,7 @@ func TestWriter_Write(t *testing.T) {
},
wantAsserter: func(t *testing.T, results <-chan apiModel.PlcWriteRequestResult) bool {
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case <-timeout.C:
t.Error("timeout")
@@ -104,7 +104,7 @@ func TestWriter_Write(t *testing.T) {
},
wantAsserter: func(t *testing.T, results <-chan apiModel.PlcWriteRequestResult) bool {
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case <-timeout.C:
t.Fatal("timeout")
diff --git a/plc4go/spi/default/DefaultBrowser.go b/plc4go/spi/default/DefaultBrowser.go
index b9bc5532de..ab7a628f48 100644
--- a/plc4go/spi/default/DefaultBrowser.go
+++ b/plc4go/spi/default/DefaultBrowser.go
@@ -21,6 +21,7 @@ package _default
import (
"context"
+ "github.com/rs/zerolog/log"
apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
"github.com/apache/plc4x/plc4go/spi"
@@ -67,6 +68,11 @@ func (m *defaultBrowser) Browse(ctx context.Context, browseRequest apiModel.PlcB
func (m *defaultBrowser) BrowseWithInterceptor(ctx context.Context, browseRequest apiModel.PlcBrowseRequest, interceptor func(result apiModel.PlcBrowseItem) bool) <-chan apiModel.PlcBrowseRequestResult {
result := make(chan apiModel.PlcBrowseRequestResult)
go func() {
+ defer func() {
+ if err := recover(); err != nil {
+ log.Error().Interface("err", err).Msg("caught panic")
+ }
+ }()
responseCodes := map[string]apiModel.PlcResponseCode{}
results := map[string][]apiModel.PlcBrowseItem{}
for _, queryName := range browseRequest.GetQueryNames() {
diff --git a/plc4go/spi/default/DefaultBrowser_test.go b/plc4go/spi/default/DefaultBrowser_test.go
index 5edb5e07a1..f7e45e1bd5 100644
--- a/plc4go/spi/default/DefaultBrowser_test.go
+++ b/plc4go/spi/default/DefaultBrowser_test.go
@@ -24,6 +24,7 @@ import (
spiModel "github.com/apache/plc4x/plc4go/spi/model"
"github.com/apache/plc4x/plc4go/spi/utils"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
"testing"
"time"
@@ -75,7 +76,7 @@ func Test_defaultBrowser_Browse(t *testing.T) {
},
wantAsserter: func(t *testing.T, results <-chan apiModel.PlcBrowseRequestResult) bool {
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case result := <-results:
assert.NotNil(t, result)
@@ -110,6 +111,7 @@ func Test_defaultBrowser_BrowseWithInterceptor(t *testing.T) {
name string
fields fields
args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
wantAsserter func(t *testing.T, results <-chan apiModel.PlcBrowseRequestResult) bool
}{
{
@@ -120,7 +122,7 @@ func Test_defaultBrowser_BrowseWithInterceptor(t *testing.T) {
},
wantAsserter: func(t *testing.T, results <-chan apiModel.PlcBrowseRequestResult) bool {
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case result := <-results:
assert.NotNil(t, result)
@@ -133,22 +135,28 @@ func Test_defaultBrowser_BrowseWithInterceptor(t *testing.T) {
},
{
name: "Browse something",
- fields: fields{
- DefaultBrowserRequirements: testBrowser{},
- },
args: args{
- ctx: context.Background(),
+ ctx: func() context.Context {
+ timeout, cancelFunc := context.WithTimeout(context.Background(), 1*time.Second)
+ t.Cleanup(cancelFunc)
+ return timeout
+ }(),
browseRequest: spiModel.NewDefaultPlcBrowseRequest(
map[string]apiModel.PlcQuery{
- "test": testQuery{},
+ "test": NewMockPlcQuery(t),
},
[]string{"test"},
nil,
),
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultBrowserRequirements(t)
+ requirements.EXPECT().BrowseQuery(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(0, nil)
+ fields.DefaultBrowserRequirements = requirements
+ },
wantAsserter: func(t *testing.T, results <-chan apiModel.PlcBrowseRequestResult) bool {
timeout := time.NewTimer(2 * time.Second)
- utils.CleanupTimer(timeout)
+ defer utils.CleanupTimer(timeout)
select {
case result := <-results:
assert.NotNil(t, result)
@@ -162,6 +170,9 @@ func Test_defaultBrowser_BrowseWithInterceptor(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
m := &defaultBrowser{
DefaultBrowserRequirements: tt.fields.DefaultBrowserRequirements,
}
diff --git a/plc4go/spi/default/DefaultCodec.go b/plc4go/spi/default/DefaultCodec.go
index 8160e7eb23..5cf97068e6 100644
--- a/plc4go/spi/default/DefaultCodec.go
+++ b/plc4go/spi/default/DefaultCodec.go
@@ -332,13 +332,13 @@ mainLoop:
if !messageHandled {
workerLog.Trace().Msg("Message was not handled")
timeout := time.NewTimer(time.Millisecond * 40)
+ defer utils.CleanupTimer(timeout)
select {
case m.defaultIncomingMessageChannel <- message:
case <-timeout.C:
timeout.Stop()
workerLog.Warn().Msgf("Message discarded\n%s", message)
}
- utils.CleanupTimer(timeout)
}
}
}
diff --git a/plc4go/spi/default/DefaultCodec_test.go b/plc4go/spi/default/DefaultCodec_test.go
index c9014d7c4c..4dfb7f3305 100644
--- a/plc4go/spi/default/DefaultCodec_test.go
+++ b/plc4go/spi/default/DefaultCodec_test.go
@@ -27,6 +27,7 @@ import (
"github.com/apache/plc4x/plc4go/spi/transports"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
"testing"
"time"
)
@@ -335,7 +336,11 @@ func Test_defaultCodec_Connect(t *testing.T) {
{
name: "connect it",
fields: fields{
- transportInstance: testTransportInstance{},
+ transportInstance: func() transports.TransportInstance {
+ instance := NewMockTransportInstance(t)
+ instance.EXPECT().IsConnected().Return(true)
+ return instance
+ }(),
},
wantErr: assert.NoError,
},
@@ -368,41 +373,47 @@ func Test_defaultCodec_ConnectWithContext(t *testing.T) {
ctx context.Context
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr assert.ErrorAssertionFunc
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr assert.ErrorAssertionFunc
}{
{
name: "connect it",
- fields: fields{
- transportInstance: testTransportInstance{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ instance := NewMockTransportInstance(t)
+ instance.EXPECT().IsConnected().Return(true)
+ fields.transportInstance = instance
},
wantErr: assert.NoError,
},
{
name: "connect it (fails)",
- fields: fields{
- transportInstance: testTransportInstance{
- connectWithContext: func(_ context.Context) error {
- return errors.New("nope")
- },
- },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ instance := NewMockTransportInstance(t)
+ expect := instance.EXPECT()
+ expect.IsConnected().Return(false)
+ expect.ConnectWithContext(mock.Anything).Return(errors.New("nope"))
+ fields.transportInstance = instance
},
wantErr: assert.Error,
},
{
name: "connect it already connected",
- fields: fields{
- transportInstance: testTransportInstance{
- connected: true,
- },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ instance := NewMockTransportInstance(t)
+ instance.EXPECT().IsConnected().Return(true)
+ fields.transportInstance = instance
},
wantErr: assert.NoError,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
m := &defaultCodec{
DefaultCodecRequirements: tt.fields.DefaultCodecRequirements,
transportInstance: tt.fields.transportInstance,
@@ -433,7 +444,11 @@ func Test_defaultCodec_Disconnect(t *testing.T) {
{
name: "disconnect it",
fields: fields{
- transportInstance: testTransportInstance{},
+ transportInstance: func() transports.TransportInstance {
+ instance := NewMockTransportInstance(t)
+ instance.EXPECT().Close().Return(nil)
+ return instance
+ }(),
},
wantErr: assert.NoError,
},
@@ -711,26 +726,26 @@ func Test_defaultCodec_SendRequest(t *testing.T) {
ttl time.Duration
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr assert.ErrorAssertionFunc
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr assert.ErrorAssertionFunc
}{
{
name: "send it",
- fields: fields{
- DefaultCodecRequirements: testMessageCodec{},
- },
args: args{
ctx: context.Background(),
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Send(mock.Anything).Return(nil)
+ fields.DefaultCodecRequirements = requirements
+ },
wantErr: assert.NoError,
},
{
name: "send it canceled",
- fields: fields{
- DefaultCodecRequirements: testMessageCodec{},
- },
args: args{
ctx: func() context.Context {
ctx, cancelFunc := context.WithCancel(context.Background())
@@ -738,25 +753,29 @@ func Test_defaultCodec_SendRequest(t *testing.T) {
return ctx
}(),
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ fields.DefaultCodecRequirements = NewMockDefaultCodecRequirements(t)
+ },
wantErr: assert.Error,
},
{
name: "send it errors",
- fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- send: func(_ spi.Message) error {
- return errors.New("nope")
- },
- },
- },
args: args{
ctx: context.Background(),
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Send(mock.Anything).Return(errors.New("nope"))
+ fields.DefaultCodecRequirements = requirements
+ },
wantErr: assert.Error,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
m := &defaultCodec{
DefaultCodecRequirements: tt.fields.DefaultCodecRequirements,
transportInstance: tt.fields.transportInstance,
@@ -857,9 +876,10 @@ func Test_defaultCodec_Work(t *testing.T) {
codec DefaultCodecRequirements
}
tests := []struct {
- name string
- fields fields
- args args
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
}{
{
name: "work it (nothing to do)",
@@ -908,8 +928,7 @@ func Test_defaultCodec_Work(t *testing.T) {
{
name: "work harder (nil message)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{},
- running: true,
+ running: true,
expectations: []spi.Expectation{
&DefaultExpectation{ // Expired
Context: context.Background(),
@@ -943,15 +962,15 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(nil, nil)
+ fields.DefaultCodecRequirements = requirements
+ },
},
{
name: "work harder (message)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- receive: func() (spi.Message, error) {
- return testMessage{}, nil
- },
- },
running: true,
expectations: []spi.Expectation{
&DefaultExpectation{ // Expired
@@ -986,15 +1005,15 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(NewMockMessage(t), nil)
+ fields.DefaultCodecRequirements = requirements
+ },
},
{
name: "work harder (message with default channel)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- receive: func() (spi.Message, error) {
- return testMessage{}, nil
- },
- },
defaultIncomingMessageChannel: make(chan spi.Message, 1),
running: true,
expectations: []spi.Expectation{
@@ -1007,15 +1026,15 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(NewMockMessage(t), nil)
+ fields.DefaultCodecRequirements = requirements
+ },
},
{
name: "work harder (message receive error)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- receive: func() (spi.Message, error) {
- return nil, errors.New("nope")
- },
- },
running: true,
expectations: []spi.Expectation{
&DefaultExpectation{ // Expired
@@ -1050,15 +1069,15 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(nil, errors.New("nope"))
+ fields.DefaultCodecRequirements = requirements
+ },
},
{
name: "work harder (message custom not handled)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- receive: func() (spi.Message, error) {
- return testMessage{}, nil
- },
- },
customMessageHandling: func(_ DefaultCodecRequirements, _ spi.Message) bool {
return false
},
@@ -1096,15 +1115,15 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(NewMockMessage(t), nil)
+ fields.DefaultCodecRequirements = requirements
+ },
},
{
name: "work harder (message custom handled)",
fields: fields{
- DefaultCodecRequirements: testMessageCodec{
- receive: func() (spi.Message, error) {
- return testMessage{}, nil
- },
- },
customMessageHandling: func(_ DefaultCodecRequirements, _ spi.Message) bool {
return true
},
@@ -1142,10 +1161,18 @@ func Test_defaultCodec_Work(t *testing.T) {
},
},
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultCodecRequirements(t)
+ requirements.EXPECT().Receive().Return(NewMockMessage(t), nil)
+ fields.DefaultCodecRequirements = requirements
+ },
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
m := &defaultCodec{
DefaultCodecRequirements: tt.fields.DefaultCodecRequirements,
transportInstance: tt.fields.transportInstance,
diff --git a/plc4go/spi/default/DefaultConnection_test.go b/plc4go/spi/default/DefaultConnection_test.go
index f6d46ab64b..76c0e457d1 100644
--- a/plc4go/spi/default/DefaultConnection_test.go
+++ b/plc4go/spi/default/DefaultConnection_test.go
@@ -23,6 +23,7 @@ import (
"context"
"fmt"
"github.com/apache/plc4x/plc4go/spi/utils"
+ "github.com/stretchr/testify/mock"
"testing"
"time"
@@ -429,18 +430,26 @@ func Test_defaultConnection_BlockingClose(t *testing.T) {
valueHandler spi.PlcValueHandler
}
tests := []struct {
- name string
- fields fields
+ name string
+ fields fields
+ mockSetup func(t *testing.T, fields *fields)
}{
{
name: "close",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ connection := NewMockPlcConnection(t)
+ connection.EXPECT().Close().Return(nil)
+ requirements.EXPECT().GetConnection().Return(connection)
+ fields.DefaultConnectionRequirements = requirements
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -469,7 +478,7 @@ func Test_defaultConnection_BrowseRequestBuilder(t *testing.T) {
{
name: "create it",
fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ DefaultConnectionRequirements: NewMockDefaultConnectionRequirements(t),
},
},
}
@@ -505,12 +514,27 @@ func Test_defaultConnection_Close(t *testing.T) {
tests := []struct {
name string
fields fields
+ mockSetup func(t *testing.T, fields *fields)
wantAsserter func(t *testing.T, results <-chan plc4go.PlcConnectionCloseResult) bool
}{
{
name: "close it",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ codec := NewMockMessageCodec(t)
+ {
+ expect := codec.EXPECT()
+ expect.Disconnect().Return(nil)
+ instance := NewMockTransportInstance(t)
+ instance.EXPECT().Close().Return(nil)
+ expect.GetTransportInstance().Return(instance)
+ }
+ {
+ expect := requirements.EXPECT()
+ expect.GetMessageCodec().Return(codec)
+ expect.GetConnection().Return(nil)
+ }
+ fields.DefaultConnectionRequirements = requirements
},
wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionCloseResult) bool {
timeout := time.NewTimer(2 * time.Second)
@@ -527,6 +551,9 @@ func Test_defaultConnection_Close(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -550,12 +577,18 @@ func Test_defaultConnection_Connect(t *testing.T) {
tests := []struct {
name string
fields fields
+ mockSetup func(t *testing.T, fields *fields)
wantAsserter func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool
}{
{
name: "connect it",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ results := make(chan plc4go.PlcConnectionConnectResult, 1)
+ results <- NewMockPlcConnectionConnectResult(t)
+ expect := requirements.EXPECT()
+ expect.ConnectWithContext(mock.Anything).Return(results)
+ fields.DefaultConnectionRequirements = requirements
},
wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
// Delegated call is tested below
@@ -565,6 +598,9 @@ func Test_defaultConnection_Connect(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -592,12 +628,21 @@ func Test_defaultConnection_ConnectWithContext(t *testing.T) {
name string
fields fields
args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
wantAsserter func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool
}{
{
name: "connect it",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ codec := NewMockMessageCodec(t)
+ {
+ codec.EXPECT().ConnectWithContext(mock.Anything).Return(nil)
+ }
+ expect := requirements.EXPECT()
+ expect.GetMessageCodec().Return(codec)
+ expect.GetConnection().Return(NewMockPlcConnection(t))
+ fields.DefaultConnectionRequirements = requirements
},
wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
timeout := time.NewTimer(2 * time.Second)
@@ -614,6 +659,9 @@ func Test_defaultConnection_ConnectWithContext(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -728,21 +776,32 @@ func Test_defaultConnection_GetTransportInstance(t *testing.T) {
tagHandler spi.PlcTagHandler
valueHandler spi.PlcValueHandler
}
+ theInstance := NewMockTransportInstance(t)
tests := []struct {
- name string
- fields fields
- want transports.TransportInstance
+ name string
+ fields fields
+ mockSetup func(t *testing.T, fields *fields)
+ want transports.TransportInstance
}{
{
name: "get it",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ codec := NewMockMessageCodec(t)
+ {
+ codec.EXPECT().GetTransportInstance().Return(theInstance)
+ }
+ requirements.EXPECT().GetMessageCodec().Return(codec)
+ fields.DefaultConnectionRequirements = requirements
},
- want: testTransportInstance{},
+ want: theInstance,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -828,12 +887,19 @@ func Test_defaultConnection_Ping(t *testing.T) {
tests := []struct {
name string
fields fields
+ mockSetup func(t *testing.T, fields *fields)
wantAsserter func(t *testing.T, results <-chan plc4go.PlcConnectionPingResult) bool
}{
{
name: "ping it",
- fields: fields{
- DefaultConnectionRequirements: testConnection{},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ connection := NewMockPlcConnection(t)
+ {
+ connection.EXPECT().IsConnected().Return(false)
+ }
+ requirements.EXPECT().GetConnection().Return(connection)
+ fields.DefaultConnectionRequirements = requirements
},
wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionPingResult) bool {
timeout := time.NewTimer(2 * time.Second)
@@ -850,11 +916,17 @@ func Test_defaultConnection_Ping(t *testing.T) {
{
name: "ping it connected",
fields: fields{
- DefaultConnectionRequirements: testConnection{
- connected: true,
- },
connected: true,
},
+ mockSetup: func(t *testing.T, fields *fields) {
+ requirements := NewMockDefaultConnectionRequirements(t)
+ connection := NewMockPlcConnection(t)
+ {
+ connection.EXPECT().IsConnected().Return(true)
+ }
+ requirements.EXPECT().GetConnection().Return(connection)
+ fields.DefaultConnectionRequirements = requirements
+ },
wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionPingResult) bool {
timeout := time.NewTimer(2 * time.Second)
defer utils.CleanupTimer(timeout)
@@ -870,6 +942,9 @@ func Test_defaultConnection_Ping(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields)
+ }
d := &defaultConnection{
DefaultConnectionRequirements: tt.fields.DefaultConnectionRequirements,
defaultTtl: tt.fields.defaultTtl,
@@ -1109,7 +1184,7 @@ func Test_plcConnectionCloseResult_GetErr(t *testing.T) {
{
name: "get it",
fields: fields{
- connection: testConnection{},
+ connection: NewMockPlcConnection(t),
},
wantErr: assert.NoError,
},
@@ -1191,7 +1266,7 @@ func Test_plcConnectionConnectResult_GetErr(t *testing.T) {
{
name: "get it",
fields: fields{
- connection: testConnection{},
+ connection: NewMockPlcConnection(t),
},
wantErr: assert.NoError,
},
diff --git a/plc4go/spi/default/DefaultDriver_test.go b/plc4go/spi/default/DefaultDriver_test.go
index 906e20f85c..9aa1e95ec2 100644
--- a/plc4go/spi/default/DefaultDriver_test.go
+++ b/plc4go/spi/default/DefaultDriver_test.go
@@ -23,6 +23,7 @@ import (
"context"
"fmt"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
"net/url"
"testing"
@@ -70,21 +71,27 @@ func Test_defaultDriver_CheckQuery(t *testing.T) {
query string
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr assert.ErrorAssertionFunc
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr assert.ErrorAssertionFunc
}{
{
name: "check it",
- fields: fields{
- plcTagHandler: testTagHandler{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ handler := NewMockPlcTagHandler(t)
+ handler.EXPECT().ParseQuery(mock.Anything).Return(nil, nil)
+ fields.plcTagHandler = handler
},
wantErr: assert.NoError,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
d := &defaultDriver{
DefaultDriverRequirements: tt.fields.DefaultDriverRequirements,
protocolCode: tt.fields.protocolCode,
@@ -109,21 +116,27 @@ func Test_defaultDriver_CheckTagAddress(t *testing.T) {
query string
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr assert.ErrorAssertionFunc
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr assert.ErrorAssertionFunc
}{
{
name: "check it",
- fields: fields{
- plcTagHandler: testTagHandler{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ handler := NewMockPlcTagHandler(t)
+ handler.EXPECT().ParseTag(mock.Anything).Return(nil, nil)
+ fields.plcTagHandler = handler
},
wantErr: assert.NoError,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
d := &defaultDriver{
DefaultDriverRequirements: tt.fields.DefaultDriverRequirements,
protocolCode: tt.fields.protocolCode,
@@ -149,21 +162,27 @@ func Test_defaultDriver_Discover(t *testing.T) {
discoveryOptions []options.WithDiscoveryOption
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr assert.ErrorAssertionFunc
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr assert.ErrorAssertionFunc
}{
{
name: "discover it",
- fields: fields{
- DefaultDriverRequirements: testDriver{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ requirements := NewMockDefaultDriverRequirements(t)
+ requirements.EXPECT().DiscoverWithContext(mock.Anything, mock.Anything).Return(nil)
+ fields.DefaultDriverRequirements = requirements
},
wantErr: assert.NoError,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
d := &defaultDriver{
DefaultDriverRequirements: tt.fields.DefaultDriverRequirements,
protocolCode: tt.fields.protocolCode,
@@ -228,21 +247,29 @@ func Test_defaultDriver_GetConnection(t *testing.T) {
options map[string][]string
}
tests := []struct {
- name string
- fields fields
- args args
- want <-chan plc4go.PlcConnectionConnectResult
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args, want *<-chan plc4go.PlcConnectionConnectResult)
+ want <-chan plc4go.PlcConnectionConnectResult
}{
{
name: "get a connection",
- fields: fields{
- DefaultDriverRequirements: testDriver{},
+ mockSetup: func(t *testing.T, fields *fields, args *args, want *<-chan plc4go.PlcConnectionConnectResult) {
+ requirements := NewMockDefaultDriverRequirements(t)
+ results := make(chan plc4go.PlcConnectionConnectResult, 1)
+ *want = results
+ results <- NewMockPlcConnectionConnectResult(t)
+ requirements.EXPECT().GetConnectionWithContext(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(results)
+ fields.DefaultDriverRequirements = requirements
},
- args: args{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args, &tt.want)
+ }
d := &defaultDriver{
DefaultDriverRequirements: tt.fields.DefaultDriverRequirements,
protocolCode: tt.fields.protocolCode,
diff --git a/plc4go/spi/default/mock_MessageCodec_test.go b/plc4go/spi/default/mock_MessageCodec_test.go
new file mode 100644
index 0000000000..f90e7062fe
--- /dev/null
+++ b/plc4go/spi/default/mock_MessageCodec_test.go
@@ -0,0 +1,447 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ context "context"
+
+ spi "github.com/apache/plc4x/plc4go/spi"
+ mock "github.com/stretchr/testify/mock"
+
+ time "time"
+
+ transports "github.com/apache/plc4x/plc4go/spi/transports"
+)
+
+// MockMessageCodec is an autogenerated mock type for the MessageCodec type
+type MockMessageCodec struct {
+ mock.Mock
+}
+
+type MockMessageCodec_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockMessageCodec) EXPECT() *MockMessageCodec_Expecter {
+ return &MockMessageCodec_Expecter{mock: &_m.Mock}
+}
+
+// Connect provides a mock function with given fields:
+func (_m *MockMessageCodec) Connect() error {
+ ret := _m.Called()
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func() error); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
+type MockMessageCodec_Connect_Call struct {
+ *mock.Call
+}
+
+// Connect is a helper method to define mock.On call
+func (_e *MockMessageCodec_Expecter) Connect() *MockMessageCodec_Connect_Call {
+ return &MockMessageCodec_Connect_Call{Call: _e.mock.On("Connect")}
+}
+
+func (_c *MockMessageCodec_Connect_Call) Run(run func()) *MockMessageCodec_Connect_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_Connect_Call) Return(_a0 error) *MockMessageCodec_Connect_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_Connect_Call) RunAndReturn(run func() error) *MockMessageCodec_Connect_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ConnectWithContext provides a mock function with given fields: ctx
+func (_m *MockMessageCodec) ConnectWithContext(ctx context.Context) error {
+ ret := _m.Called(ctx)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context) error); ok {
+ r0 = rf(ctx)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_ConnectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectWithContext'
+type MockMessageCodec_ConnectWithContext_Call struct {
+ *mock.Call
+}
+
+// ConnectWithContext is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockMessageCodec_Expecter) ConnectWithContext(ctx interface{}) *MockMessageCodec_ConnectWithContext_Call {
+ return &MockMessageCodec_ConnectWithContext_Call{Call: _e.mock.On("ConnectWithContext", ctx)}
+}
+
+func (_c *MockMessageCodec_ConnectWithContext_Call) Run(run func(ctx context.Context)) *MockMessageCodec_ConnectWithContext_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_ConnectWithContext_Call) Return(_a0 error) *MockMessageCodec_ConnectWithContext_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_ConnectWithContext_Call) RunAndReturn(run func(context.Context) error) *MockMessageCodec_ConnectWithContext_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Disconnect provides a mock function with given fields:
+func (_m *MockMessageCodec) Disconnect() error {
+ ret := _m.Called()
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func() error); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect'
+type MockMessageCodec_Disconnect_Call struct {
+ *mock.Call
+}
+
+// Disconnect is a helper method to define mock.On call
+func (_e *MockMessageCodec_Expecter) Disconnect() *MockMessageCodec_Disconnect_Call {
+ return &MockMessageCodec_Disconnect_Call{Call: _e.mock.On("Disconnect")}
+}
+
+func (_c *MockMessageCodec_Disconnect_Call) Run(run func()) *MockMessageCodec_Disconnect_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_Disconnect_Call) Return(_a0 error) *MockMessageCodec_Disconnect_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_Disconnect_Call) RunAndReturn(run func() error) *MockMessageCodec_Disconnect_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Expect provides a mock function with given fields: ctx, acceptsMessage, handleMessage, handleError, ttl
+func (_m *MockMessageCodec) Expect(ctx context.Context, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration) error {
+ ret := _m.Called(ctx, acceptsMessage, handleMessage, handleError, ttl)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context, spi.AcceptsMessage, spi.HandleMessage, spi.HandleError, time.Duration) error); ok {
+ r0 = rf(ctx, acceptsMessage, handleMessage, handleError, ttl)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_Expect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expect'
+type MockMessageCodec_Expect_Call struct {
+ *mock.Call
+}
+
+// Expect is a helper method to define mock.On call
+// - ctx context.Context
+// - acceptsMessage spi.AcceptsMessage
+// - handleMessage spi.HandleMessage
+// - handleError spi.HandleError
+// - ttl time.Duration
+func (_e *MockMessageCodec_Expecter) Expect(ctx interface{}, acceptsMessage interface{}, handleMessage interface{}, handleError interface{}, ttl interface{}) *MockMessageCodec_Expect_Call {
+ return &MockMessageCodec_Expect_Call{Call: _e.mock.On("Expect", ctx, acceptsMessage, handleMessage, handleError, ttl)}
+}
+
+func (_c *MockMessageCodec_Expect_Call) Run(run func(ctx context.Context, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration)) *MockMessageCodec_Expect_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(spi.AcceptsMessage), args[2].(spi.HandleMessage), args[3].(spi.HandleError), args[4].(time.Duration))
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_Expect_Call) Return(_a0 error) *MockMessageCodec_Expect_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_Expect_Call) RunAndReturn(run func(context.Context, spi.AcceptsMessage, spi.HandleMessage, spi.HandleError, time.Duration) error) *MockMessageCodec_Expect_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetDefaultIncomingMessageChannel provides a mock function with given fields:
+func (_m *MockMessageCodec) GetDefaultIncomingMessageChannel() chan spi.Message {
+ ret := _m.Called()
+
+ var r0 chan spi.Message
+ if rf, ok := ret.Get(0).(func() chan spi.Message); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(chan spi.Message)
+ }
+ }
+
+ return r0
+}
+
+// MockMessageCodec_GetDefaultIncomingMessageChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultIncomingMessageChannel'
+type MockMessageCodec_GetDefaultIncomingMessageChannel_Call struct {
+ *mock.Call
+}
+
+// GetDefaultIncomingMessageChannel is a helper method to define mock.On call
+func (_e *MockMessageCodec_Expecter) GetDefaultIncomingMessageChannel() *MockMessageCodec_GetDefaultIncomingMessageChannel_Call {
+ return &MockMessageCodec_GetDefaultIncomingMessageChannel_Call{Call: _e.mock.On("GetDefaultIncomingMessageChannel")}
+}
+
+func (_c *MockMessageCodec_GetDefaultIncomingMessageChannel_Call) Run(run func()) *MockMessageCodec_GetDefaultIncomingMessageChannel_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_GetDefaultIncomingMessageChannel_Call) Return(_a0 chan spi.Message) *MockMessageCodec_GetDefaultIncomingMessageChannel_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_GetDefaultIncomingMessageChannel_Call) RunAndReturn(run func() chan spi.Message) *MockMessageCodec_GetDefaultIncomingMessageChannel_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTransportInstance provides a mock function with given fields:
+func (_m *MockMessageCodec) GetTransportInstance() transports.TransportInstance {
+ ret := _m.Called()
+
+ var r0 transports.TransportInstance
+ if rf, ok := ret.Get(0).(func() transports.TransportInstance); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(transports.TransportInstance)
+ }
+ }
+
+ return r0
+}
+
+// MockMessageCodec_GetTransportInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransportInstance'
+type MockMessageCodec_GetTransportInstance_Call struct {
+ *mock.Call
+}
+
+// GetTransportInstance is a helper method to define mock.On call
+func (_e *MockMessageCodec_Expecter) GetTransportInstance() *MockMessageCodec_GetTransportInstance_Call {
+ return &MockMessageCodec_GetTransportInstance_Call{Call: _e.mock.On("GetTransportInstance")}
+}
+
+func (_c *MockMessageCodec_GetTransportInstance_Call) Run(run func()) *MockMessageCodec_GetTransportInstance_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_GetTransportInstance_Call) Return(_a0 transports.TransportInstance) *MockMessageCodec_GetTransportInstance_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_GetTransportInstance_Call) RunAndReturn(run func() transports.TransportInstance) *MockMessageCodec_GetTransportInstance_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsRunning provides a mock function with given fields:
+func (_m *MockMessageCodec) IsRunning() bool {
+ ret := _m.Called()
+
+ var r0 bool
+ if rf, ok := ret.Get(0).(func() bool); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(bool)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_IsRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsRunning'
+type MockMessageCodec_IsRunning_Call struct {
+ *mock.Call
+}
+
+// IsRunning is a helper method to define mock.On call
+func (_e *MockMessageCodec_Expecter) IsRunning() *MockMessageCodec_IsRunning_Call {
+ return &MockMessageCodec_IsRunning_Call{Call: _e.mock.On("IsRunning")}
+}
+
+func (_c *MockMessageCodec_IsRunning_Call) Run(run func()) *MockMessageCodec_IsRunning_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_IsRunning_Call) Return(_a0 bool) *MockMessageCodec_IsRunning_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_IsRunning_Call) RunAndReturn(run func() bool) *MockMessageCodec_IsRunning_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Send provides a mock function with given fields: message
+func (_m *MockMessageCodec) Send(message spi.Message) error {
+ ret := _m.Called(message)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(spi.Message) error); ok {
+ r0 = rf(message)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type MockMessageCodec_Send_Call struct {
+ *mock.Call
+}
+
+// Send is a helper method to define mock.On call
+// - message spi.Message
+func (_e *MockMessageCodec_Expecter) Send(message interface{}) *MockMessageCodec_Send_Call {
+ return &MockMessageCodec_Send_Call{Call: _e.mock.On("Send", message)}
+}
+
+func (_c *MockMessageCodec_Send_Call) Run(run func(message spi.Message)) *MockMessageCodec_Send_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(spi.Message))
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_Send_Call) Return(_a0 error) *MockMessageCodec_Send_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_Send_Call) RunAndReturn(run func(spi.Message) error) *MockMessageCodec_Send_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// SendRequest provides a mock function with given fields: ctx, message, acceptsMessage, handleMessage, handleError, ttl
+func (_m *MockMessageCodec) SendRequest(ctx context.Context, message spi.Message, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration) error {
+ ret := _m.Called(ctx, message, acceptsMessage, handleMessage, handleError, ttl)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context, spi.Message, spi.AcceptsMessage, spi.HandleMessage, spi.HandleError, time.Duration) error); ok {
+ r0 = rf(ctx, message, acceptsMessage, handleMessage, handleError, ttl)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessageCodec_SendRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendRequest'
+type MockMessageCodec_SendRequest_Call struct {
+ *mock.Call
+}
+
+// SendRequest is a helper method to define mock.On call
+// - ctx context.Context
+// - message spi.Message
+// - acceptsMessage spi.AcceptsMessage
+// - handleMessage spi.HandleMessage
+// - handleError spi.HandleError
+// - ttl time.Duration
+func (_e *MockMessageCodec_Expecter) SendRequest(ctx interface{}, message interface{}, acceptsMessage interface{}, handleMessage interface{}, handleError interface{}, ttl interface{}) *MockMessageCodec_SendRequest_Call {
+ return &MockMessageCodec_SendRequest_Call{Call: _e.mock.On("SendRequest", ctx, message, acceptsMessage, handleMessage, handleError, ttl)}
+}
+
+func (_c *MockMessageCodec_SendRequest_Call) Run(run func(ctx context.Context, message spi.Message, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration)) *MockMessageCodec_SendRequest_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(spi.Message), args[2].(spi.AcceptsMessage), args[3].(spi.HandleMessage), args[4].(spi.HandleError), args[5].(time.Duration))
+ })
+ return _c
+}
+
+func (_c *MockMessageCodec_SendRequest_Call) Return(_a0 error) *MockMessageCodec_SendRequest_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessageCodec_SendRequest_Call) RunAndReturn(run func(context.Context, spi.Message, spi.AcceptsMessage, spi.HandleMessage, spi.HandleError, time.Duration) error) *MockMessageCodec_SendRequest_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockMessageCodec interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockMessageCodec creates a new instance of MockMessageCodec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockMessageCodec(t mockConstructorTestingTNewMockMessageCodec) *MockMessageCodec {
+ mock := &MockMessageCodec{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_Message_test.go b/plc4go/spi/default/mock_Message_test.go
new file mode 100644
index 0000000000..2a32a6a412
--- /dev/null
+++ b/plc4go/spi/default/mock_Message_test.go
@@ -0,0 +1,237 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ context "context"
+
+ utils "github.com/apache/plc4x/plc4go/spi/utils"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockMessage is an autogenerated mock type for the Message type
+type MockMessage struct {
+ mock.Mock
+}
+
+type MockMessage_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockMessage) EXPECT() *MockMessage_Expecter {
+ return &MockMessage_Expecter{mock: &_m.Mock}
+}
+
+// GetLengthInBits provides a mock function with given fields: ctx
+func (_m *MockMessage) GetLengthInBits(ctx context.Context) uint16 {
+ ret := _m.Called(ctx)
+
+ var r0 uint16
+ if rf, ok := ret.Get(0).(func(context.Context) uint16); ok {
+ r0 = rf(ctx)
+ } else {
+ r0 = ret.Get(0).(uint16)
+ }
+
+ return r0
+}
+
+// MockMessage_GetLengthInBits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLengthInBits'
+type MockMessage_GetLengthInBits_Call struct {
+ *mock.Call
+}
+
+// GetLengthInBits is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockMessage_Expecter) GetLengthInBits(ctx interface{}) *MockMessage_GetLengthInBits_Call {
+ return &MockMessage_GetLengthInBits_Call{Call: _e.mock.On("GetLengthInBits", ctx)}
+}
+
+func (_c *MockMessage_GetLengthInBits_Call) Run(run func(ctx context.Context)) *MockMessage_GetLengthInBits_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockMessage_GetLengthInBits_Call) Return(_a0 uint16) *MockMessage_GetLengthInBits_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessage_GetLengthInBits_Call) RunAndReturn(run func(context.Context) uint16) *MockMessage_GetLengthInBits_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetLengthInBytes provides a mock function with given fields: ctx
+func (_m *MockMessage) GetLengthInBytes(ctx context.Context) uint16 {
+ ret := _m.Called(ctx)
+
+ var r0 uint16
+ if rf, ok := ret.Get(0).(func(context.Context) uint16); ok {
+ r0 = rf(ctx)
+ } else {
+ r0 = ret.Get(0).(uint16)
+ }
+
+ return r0
+}
+
+// MockMessage_GetLengthInBytes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLengthInBytes'
+type MockMessage_GetLengthInBytes_Call struct {
+ *mock.Call
+}
+
+// GetLengthInBytes is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockMessage_Expecter) GetLengthInBytes(ctx interface{}) *MockMessage_GetLengthInBytes_Call {
+ return &MockMessage_GetLengthInBytes_Call{Call: _e.mock.On("GetLengthInBytes", ctx)}
+}
+
+func (_c *MockMessage_GetLengthInBytes_Call) Run(run func(ctx context.Context)) *MockMessage_GetLengthInBytes_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockMessage_GetLengthInBytes_Call) Return(_a0 uint16) *MockMessage_GetLengthInBytes_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessage_GetLengthInBytes_Call) RunAndReturn(run func(context.Context) uint16) *MockMessage_GetLengthInBytes_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Serialize provides a mock function with given fields:
+func (_m *MockMessage) Serialize() ([]byte, error) {
+ ret := _m.Called()
+
+ var r0 []byte
+ var r1 error
+ if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+ return rf()
+ }
+ if rf, ok := ret.Get(0).(func() []byte); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]byte)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func() error); ok {
+ r1 = rf()
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockMessage_Serialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Serialize'
+type MockMessage_Serialize_Call struct {
+ *mock.Call
+}
+
+// Serialize is a helper method to define mock.On call
+func (_e *MockMessage_Expecter) Serialize() *MockMessage_Serialize_Call {
+ return &MockMessage_Serialize_Call{Call: _e.mock.On("Serialize")}
+}
+
+func (_c *MockMessage_Serialize_Call) Run(run func()) *MockMessage_Serialize_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockMessage_Serialize_Call) Return(_a0 []byte, _a1 error) *MockMessage_Serialize_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockMessage_Serialize_Call) RunAndReturn(run func() ([]byte, error)) *MockMessage_Serialize_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// SerializeWithWriteBuffer provides a mock function with given fields: ctx, writeBuffer
+func (_m *MockMessage) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
+ ret := _m.Called(ctx, writeBuffer)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context, utils.WriteBuffer) error); ok {
+ r0 = rf(ctx, writeBuffer)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockMessage_SerializeWithWriteBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SerializeWithWriteBuffer'
+type MockMessage_SerializeWithWriteBuffer_Call struct {
+ *mock.Call
+}
+
+// SerializeWithWriteBuffer is a helper method to define mock.On call
+// - ctx context.Context
+// - writeBuffer utils.WriteBuffer
+func (_e *MockMessage_Expecter) SerializeWithWriteBuffer(ctx interface{}, writeBuffer interface{}) *MockMessage_SerializeWithWriteBuffer_Call {
+ return &MockMessage_SerializeWithWriteBuffer_Call{Call: _e.mock.On("SerializeWithWriteBuffer", ctx, writeBuffer)}
+}
+
+func (_c *MockMessage_SerializeWithWriteBuffer_Call) Run(run func(ctx context.Context, writeBuffer utils.WriteBuffer)) *MockMessage_SerializeWithWriteBuffer_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(utils.WriteBuffer))
+ })
+ return _c
+}
+
+func (_c *MockMessage_SerializeWithWriteBuffer_Call) Return(_a0 error) *MockMessage_SerializeWithWriteBuffer_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockMessage_SerializeWithWriteBuffer_Call) RunAndReturn(run func(context.Context, utils.WriteBuffer) error) *MockMessage_SerializeWithWriteBuffer_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockMessage interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockMessage creates a new instance of MockMessage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockMessage(t mockConstructorTestingTNewMockMessage) *MockMessage {
+ mock := &MockMessage{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_PlcConnectionConnectResult_test.go b/plc4go/spi/default/mock_PlcConnectionConnectResult_test.go
new file mode 100644
index 0000000000..2f46bbb847
--- /dev/null
+++ b/plc4go/spi/default/mock_PlcConnectionConnectResult_test.go
@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ plc4go "github.com/apache/plc4x/plc4go/pkg/api"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockPlcConnectionConnectResult is an autogenerated mock type for the PlcConnectionConnectResult type
+type MockPlcConnectionConnectResult struct {
+ mock.Mock
+}
+
+type MockPlcConnectionConnectResult_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcConnectionConnectResult) EXPECT() *MockPlcConnectionConnectResult_Expecter {
+ return &MockPlcConnectionConnectResult_Expecter{mock: &_m.Mock}
+}
+
+// GetConnection provides a mock function with given fields:
+func (_m *MockPlcConnectionConnectResult) GetConnection() plc4go.PlcConnection {
+ ret := _m.Called()
+
+ var r0 plc4go.PlcConnection
+ if rf, ok := ret.Get(0).(func() plc4go.PlcConnection); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(plc4go.PlcConnection)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnectionConnectResult_GetConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnection'
+type MockPlcConnectionConnectResult_GetConnection_Call struct {
+ *mock.Call
+}
+
+// GetConnection is a helper method to define mock.On call
+func (_e *MockPlcConnectionConnectResult_Expecter) GetConnection() *MockPlcConnectionConnectResult_GetConnection_Call {
+ return &MockPlcConnectionConnectResult_GetConnection_Call{Call: _e.mock.On("GetConnection")}
+}
+
+func (_c *MockPlcConnectionConnectResult_GetConnection_Call) Run(run func()) *MockPlcConnectionConnectResult_GetConnection_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnectionConnectResult_GetConnection_Call) Return(_a0 plc4go.PlcConnection) *MockPlcConnectionConnectResult_GetConnection_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnectionConnectResult_GetConnection_Call) RunAndReturn(run func() plc4go.PlcConnection) *MockPlcConnectionConnectResult_GetConnection_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetErr provides a mock function with given fields:
+func (_m *MockPlcConnectionConnectResult) GetErr() error {
+ ret := _m.Called()
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func() error); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockPlcConnectionConnectResult_GetErr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetErr'
+type MockPlcConnectionConnectResult_GetErr_Call struct {
+ *mock.Call
+}
+
+// GetErr is a helper method to define mock.On call
+func (_e *MockPlcConnectionConnectResult_Expecter) GetErr() *MockPlcConnectionConnectResult_GetErr_Call {
+ return &MockPlcConnectionConnectResult_GetErr_Call{Call: _e.mock.On("GetErr")}
+}
+
+func (_c *MockPlcConnectionConnectResult_GetErr_Call) Run(run func()) *MockPlcConnectionConnectResult_GetErr_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnectionConnectResult_GetErr_Call) Return(_a0 error) *MockPlcConnectionConnectResult_GetErr_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnectionConnectResult_GetErr_Call) RunAndReturn(run func() error) *MockPlcConnectionConnectResult_GetErr_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcConnectionConnectResult interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcConnectionConnectResult creates a new instance of MockPlcConnectionConnectResult. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcConnectionConnectResult(t mockConstructorTestingTNewMockPlcConnectionConnectResult) *MockPlcConnectionConnectResult {
+ mock := &MockPlcConnectionConnectResult{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_PlcConnection_test.go b/plc4go/spi/default/mock_PlcConnection_test.go
new file mode 100644
index 0000000000..e4a465fc62
--- /dev/null
+++ b/plc4go/spi/default/mock_PlcConnection_test.go
@@ -0,0 +1,563 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ context "context"
+
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+
+ plc4go "github.com/apache/plc4x/plc4go/pkg/api"
+)
+
+// MockPlcConnection is an autogenerated mock type for the PlcConnection type
+type MockPlcConnection struct {
+ mock.Mock
+}
+
+type MockPlcConnection_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcConnection) EXPECT() *MockPlcConnection_Expecter {
+ return &MockPlcConnection_Expecter{mock: &_m.Mock}
+}
+
+// BlockingClose provides a mock function with given fields:
+func (_m *MockPlcConnection) BlockingClose() {
+ _m.Called()
+}
+
+// MockPlcConnection_BlockingClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockingClose'
+type MockPlcConnection_BlockingClose_Call struct {
+ *mock.Call
+}
+
+// BlockingClose is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) BlockingClose() *MockPlcConnection_BlockingClose_Call {
+ return &MockPlcConnection_BlockingClose_Call{Call: _e.mock.On("BlockingClose")}
+}
+
+func (_c *MockPlcConnection_BlockingClose_Call) Run(run func()) *MockPlcConnection_BlockingClose_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_BlockingClose_Call) Return() *MockPlcConnection_BlockingClose_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockPlcConnection_BlockingClose_Call) RunAndReturn(run func()) *MockPlcConnection_BlockingClose_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// BrowseRequestBuilder provides a mock function with given fields:
+func (_m *MockPlcConnection) BrowseRequestBuilder() model.PlcBrowseRequestBuilder {
+ ret := _m.Called()
+
+ var r0 model.PlcBrowseRequestBuilder
+ if rf, ok := ret.Get(0).(func() model.PlcBrowseRequestBuilder); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcBrowseRequestBuilder)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_BrowseRequestBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BrowseRequestBuilder'
+type MockPlcConnection_BrowseRequestBuilder_Call struct {
+ *mock.Call
+}
+
+// BrowseRequestBuilder is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) BrowseRequestBuilder() *MockPlcConnection_BrowseRequestBuilder_Call {
+ return &MockPlcConnection_BrowseRequestBuilder_Call{Call: _e.mock.On("BrowseRequestBuilder")}
+}
+
+func (_c *MockPlcConnection_BrowseRequestBuilder_Call) Run(run func()) *MockPlcConnection_BrowseRequestBuilder_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_BrowseRequestBuilder_Call) Return(_a0 model.PlcBrowseRequestBuilder) *MockPlcConnection_BrowseRequestBuilder_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_BrowseRequestBuilder_Call) RunAndReturn(run func() model.PlcBrowseRequestBuilder) *MockPlcConnection_BrowseRequestBuilder_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Close provides a mock function with given fields:
+func (_m *MockPlcConnection) Close() <-chan plc4go.PlcConnectionCloseResult {
+ ret := _m.Called()
+
+ var r0 <-chan plc4go.PlcConnectionCloseResult
+ if rf, ok := ret.Get(0).(func() <-chan plc4go.PlcConnectionCloseResult); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan plc4go.PlcConnectionCloseResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockPlcConnection_Close_Call struct {
+ *mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) Close() *MockPlcConnection_Close_Call {
+ return &MockPlcConnection_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockPlcConnection_Close_Call) Run(run func()) *MockPlcConnection_Close_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_Close_Call) Return(_a0 <-chan plc4go.PlcConnectionCloseResult) *MockPlcConnection_Close_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_Close_Call) RunAndReturn(run func() <-chan plc4go.PlcConnectionCloseResult) *MockPlcConnection_Close_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Connect provides a mock function with given fields:
+func (_m *MockPlcConnection) Connect() <-chan plc4go.PlcConnectionConnectResult {
+ ret := _m.Called()
+
+ var r0 <-chan plc4go.PlcConnectionConnectResult
+ if rf, ok := ret.Get(0).(func() <-chan plc4go.PlcConnectionConnectResult); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan plc4go.PlcConnectionConnectResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
+type MockPlcConnection_Connect_Call struct {
+ *mock.Call
+}
+
+// Connect is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) Connect() *MockPlcConnection_Connect_Call {
+ return &MockPlcConnection_Connect_Call{Call: _e.mock.On("Connect")}
+}
+
+func (_c *MockPlcConnection_Connect_Call) Run(run func()) *MockPlcConnection_Connect_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_Connect_Call) Return(_a0 <-chan plc4go.PlcConnectionConnectResult) *MockPlcConnection_Connect_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_Connect_Call) RunAndReturn(run func() <-chan plc4go.PlcConnectionConnectResult) *MockPlcConnection_Connect_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ConnectWithContext provides a mock function with given fields: ctx
+func (_m *MockPlcConnection) ConnectWithContext(ctx context.Context) <-chan plc4go.PlcConnectionConnectResult {
+ ret := _m.Called(ctx)
+
+ var r0 <-chan plc4go.PlcConnectionConnectResult
+ if rf, ok := ret.Get(0).(func(context.Context) <-chan plc4go.PlcConnectionConnectResult); ok {
+ r0 = rf(ctx)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan plc4go.PlcConnectionConnectResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_ConnectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectWithContext'
+type MockPlcConnection_ConnectWithContext_Call struct {
+ *mock.Call
+}
+
+// ConnectWithContext is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockPlcConnection_Expecter) ConnectWithContext(ctx interface{}) *MockPlcConnection_ConnectWithContext_Call {
+ return &MockPlcConnection_ConnectWithContext_Call{Call: _e.mock.On("ConnectWithContext", ctx)}
+}
+
+func (_c *MockPlcConnection_ConnectWithContext_Call) Run(run func(ctx context.Context)) *MockPlcConnection_ConnectWithContext_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_ConnectWithContext_Call) Return(_a0 <-chan plc4go.PlcConnectionConnectResult) *MockPlcConnection_ConnectWithContext_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_ConnectWithContext_Call) RunAndReturn(run func(context.Context) <-chan plc4go.PlcConnectionConnectResult) *MockPlcConnection_ConnectWithContext_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetMetadata provides a mock function with given fields:
+func (_m *MockPlcConnection) GetMetadata() model.PlcConnectionMetadata {
+ ret := _m.Called()
+
+ var r0 model.PlcConnectionMetadata
+ if rf, ok := ret.Get(0).(func() model.PlcConnectionMetadata); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcConnectionMetadata)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata'
+type MockPlcConnection_GetMetadata_Call struct {
+ *mock.Call
+}
+
+// GetMetadata is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) GetMetadata() *MockPlcConnection_GetMetadata_Call {
+ return &MockPlcConnection_GetMetadata_Call{Call: _e.mock.On("GetMetadata")}
+}
+
+func (_c *MockPlcConnection_GetMetadata_Call) Run(run func()) *MockPlcConnection_GetMetadata_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_GetMetadata_Call) Return(_a0 model.PlcConnectionMetadata) *MockPlcConnection_GetMetadata_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_GetMetadata_Call) RunAndReturn(run func() model.PlcConnectionMetadata) *MockPlcConnection_GetMetadata_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsConnected provides a mock function with given fields:
+func (_m *MockPlcConnection) IsConnected() bool {
+ ret := _m.Called()
+
+ var r0 bool
+ if rf, ok := ret.Get(0).(func() bool); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(bool)
+ }
+
+ return r0
+}
+
+// MockPlcConnection_IsConnected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsConnected'
+type MockPlcConnection_IsConnected_Call struct {
+ *mock.Call
+}
+
+// IsConnected is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) IsConnected() *MockPlcConnection_IsConnected_Call {
+ return &MockPlcConnection_IsConnected_Call{Call: _e.mock.On("IsConnected")}
+}
+
+func (_c *MockPlcConnection_IsConnected_Call) Run(run func()) *MockPlcConnection_IsConnected_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_IsConnected_Call) Return(_a0 bool) *MockPlcConnection_IsConnected_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_IsConnected_Call) RunAndReturn(run func() bool) *MockPlcConnection_IsConnected_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Ping provides a mock function with given fields:
+func (_m *MockPlcConnection) Ping() <-chan plc4go.PlcConnectionPingResult {
+ ret := _m.Called()
+
+ var r0 <-chan plc4go.PlcConnectionPingResult
+ if rf, ok := ret.Get(0).(func() <-chan plc4go.PlcConnectionPingResult); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan plc4go.PlcConnectionPingResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'
+type MockPlcConnection_Ping_Call struct {
+ *mock.Call
+}
+
+// Ping is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) Ping() *MockPlcConnection_Ping_Call {
+ return &MockPlcConnection_Ping_Call{Call: _e.mock.On("Ping")}
+}
+
+func (_c *MockPlcConnection_Ping_Call) Run(run func()) *MockPlcConnection_Ping_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_Ping_Call) Return(_a0 <-chan plc4go.PlcConnectionPingResult) *MockPlcConnection_Ping_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_Ping_Call) RunAndReturn(run func() <-chan plc4go.PlcConnectionPingResult) *MockPlcConnection_Ping_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ReadRequestBuilder provides a mock function with given fields:
+func (_m *MockPlcConnection) ReadRequestBuilder() model.PlcReadRequestBuilder {
+ ret := _m.Called()
+
+ var r0 model.PlcReadRequestBuilder
+ if rf, ok := ret.Get(0).(func() model.PlcReadRequestBuilder); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcReadRequestBuilder)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_ReadRequestBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadRequestBuilder'
+type MockPlcConnection_ReadRequestBuilder_Call struct {
+ *mock.Call
+}
+
+// ReadRequestBuilder is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) ReadRequestBuilder() *MockPlcConnection_ReadRequestBuilder_Call {
+ return &MockPlcConnection_ReadRequestBuilder_Call{Call: _e.mock.On("ReadRequestBuilder")}
+}
+
+func (_c *MockPlcConnection_ReadRequestBuilder_Call) Run(run func()) *MockPlcConnection_ReadRequestBuilder_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_ReadRequestBuilder_Call) Return(_a0 model.PlcReadRequestBuilder) *MockPlcConnection_ReadRequestBuilder_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_ReadRequestBuilder_Call) RunAndReturn(run func() model.PlcReadRequestBuilder) *MockPlcConnection_ReadRequestBuilder_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// SubscriptionRequestBuilder provides a mock function with given fields:
+func (_m *MockPlcConnection) SubscriptionRequestBuilder() model.PlcSubscriptionRequestBuilder {
+ ret := _m.Called()
+
+ var r0 model.PlcSubscriptionRequestBuilder
+ if rf, ok := ret.Get(0).(func() model.PlcSubscriptionRequestBuilder); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcSubscriptionRequestBuilder)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_SubscriptionRequestBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionRequestBuilder'
+type MockPlcConnection_SubscriptionRequestBuilder_Call struct {
+ *mock.Call
+}
+
+// SubscriptionRequestBuilder is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) SubscriptionRequestBuilder() *MockPlcConnection_SubscriptionRequestBuilder_Call {
+ return &MockPlcConnection_SubscriptionRequestBuilder_Call{Call: _e.mock.On("SubscriptionRequestBuilder")}
+}
+
+func (_c *MockPlcConnection_SubscriptionRequestBuilder_Call) Run(run func()) *MockPlcConnection_SubscriptionRequestBuilder_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_SubscriptionRequestBuilder_Call) Return(_a0 model.PlcSubscriptionRequestBuilder) *MockPlcConnection_SubscriptionRequestBuilder_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_SubscriptionRequestBuilder_Call) RunAndReturn(run func() model.PlcSubscriptionRequestBuilder) *MockPlcConnection_SubscriptionRequestBuilder_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// UnsubscriptionRequestBuilder provides a mock function with given fields:
+func (_m *MockPlcConnection) UnsubscriptionRequestBuilder() model.PlcUnsubscriptionRequestBuilder {
+ ret := _m.Called()
+
+ var r0 model.PlcUnsubscriptionRequestBuilder
+ if rf, ok := ret.Get(0).(func() model.PlcUnsubscriptionRequestBuilder); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcUnsubscriptionRequestBuilder)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_UnsubscriptionRequestBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsubscriptionRequestBuilder'
+type MockPlcConnection_UnsubscriptionRequestBuilder_Call struct {
+ *mock.Call
+}
+
+// UnsubscriptionRequestBuilder is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) UnsubscriptionRequestBuilder() *MockPlcConnection_UnsubscriptionRequestBuilder_Call {
+ return &MockPlcConnection_UnsubscriptionRequestBuilder_Call{Call: _e.mock.On("UnsubscriptionRequestBuilder")}
+}
+
+func (_c *MockPlcConnection_UnsubscriptionRequestBuilder_Call) Run(run func()) *MockPlcConnection_UnsubscriptionRequestBuilder_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_UnsubscriptionRequestBuilder_Call) Return(_a0 model.PlcUnsubscriptionRequestBuilder) *MockPlcConnection_UnsubscriptionRequestBuilder_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_UnsubscriptionRequestBuilder_Call) RunAndReturn(run func() model.PlcUnsubscriptionRequestBuilder) *MockPlcConnection_UnsubscriptionRequestBuilder_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// WriteRequestBuilder provides a mock function with given fields:
+func (_m *MockPlcConnection) WriteRequestBuilder() model.PlcWriteRequestBuilder {
+ ret := _m.Called()
+
+ var r0 model.PlcWriteRequestBuilder
+ if rf, ok := ret.Get(0).(func() model.PlcWriteRequestBuilder); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcWriteRequestBuilder)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcConnection_WriteRequestBuilder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteRequestBuilder'
+type MockPlcConnection_WriteRequestBuilder_Call struct {
+ *mock.Call
+}
+
+// WriteRequestBuilder is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) WriteRequestBuilder() *MockPlcConnection_WriteRequestBuilder_Call {
+ return &MockPlcConnection_WriteRequestBuilder_Call{Call: _e.mock.On("WriteRequestBuilder")}
+}
+
+func (_c *MockPlcConnection_WriteRequestBuilder_Call) Run(run func()) *MockPlcConnection_WriteRequestBuilder_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_WriteRequestBuilder_Call) Return(_a0 model.PlcWriteRequestBuilder) *MockPlcConnection_WriteRequestBuilder_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcConnection_WriteRequestBuilder_Call) RunAndReturn(run func() model.PlcWriteRequestBuilder) *MockPlcConnection_WriteRequestBuilder_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcConnection interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcConnection creates a new instance of MockPlcConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcConnection(t mockConstructorTestingTNewMockPlcConnection) *MockPlcConnection {
+ mock := &MockPlcConnection{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_PlcQuery_test.go b/plc4go/spi/default/mock_PlcQuery_test.go
new file mode 100644
index 0000000000..ecd9e996ab
--- /dev/null
+++ b/plc4go/spi/default/mock_PlcQuery_test.go
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockPlcQuery is an autogenerated mock type for the PlcQuery type
+type MockPlcQuery struct {
+ mock.Mock
+}
+
+type MockPlcQuery_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcQuery) EXPECT() *MockPlcQuery_Expecter {
+ return &MockPlcQuery_Expecter{mock: &_m.Mock}
+}
+
+// GetQueryString provides a mock function with given fields:
+func (_m *MockPlcQuery) GetQueryString() string {
+ ret := _m.Called()
+
+ var r0 string
+ if rf, ok := ret.Get(0).(func() string); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(string)
+ }
+
+ return r0
+}
+
+// MockPlcQuery_GetQueryString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueryString'
+type MockPlcQuery_GetQueryString_Call struct {
+ *mock.Call
+}
+
+// GetQueryString is a helper method to define mock.On call
+func (_e *MockPlcQuery_Expecter) GetQueryString() *MockPlcQuery_GetQueryString_Call {
+ return &MockPlcQuery_GetQueryString_Call{Call: _e.mock.On("GetQueryString")}
+}
+
+func (_c *MockPlcQuery_GetQueryString_Call) Run(run func()) *MockPlcQuery_GetQueryString_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcQuery_GetQueryString_Call) Return(_a0 string) *MockPlcQuery_GetQueryString_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcQuery_GetQueryString_Call) RunAndReturn(run func() string) *MockPlcQuery_GetQueryString_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcQuery interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcQuery creates a new instance of MockPlcQuery. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcQuery(t mockConstructorTestingTNewMockPlcQuery) *MockPlcQuery {
+ mock := &MockPlcQuery{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_PlcTagHandler_test.go b/plc4go/spi/default/mock_PlcTagHandler_test.go
new file mode 100644
index 0000000000..ac6c7388a6
--- /dev/null
+++ b/plc4go/spi/default/mock_PlcTagHandler_test.go
@@ -0,0 +1,163 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockPlcTagHandler is an autogenerated mock type for the PlcTagHandler type
+type MockPlcTagHandler struct {
+ mock.Mock
+}
+
+type MockPlcTagHandler_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcTagHandler) EXPECT() *MockPlcTagHandler_Expecter {
+ return &MockPlcTagHandler_Expecter{mock: &_m.Mock}
+}
+
+// ParseQuery provides a mock function with given fields: query
+func (_m *MockPlcTagHandler) ParseQuery(query string) (model.PlcQuery, error) {
+ ret := _m.Called(query)
+
+ var r0 model.PlcQuery
+ var r1 error
+ if rf, ok := ret.Get(0).(func(string) (model.PlcQuery, error)); ok {
+ return rf(query)
+ }
+ if rf, ok := ret.Get(0).(func(string) model.PlcQuery); ok {
+ r0 = rf(query)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcQuery)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(string) error); ok {
+ r1 = rf(query)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockPlcTagHandler_ParseQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParseQuery'
+type MockPlcTagHandler_ParseQuery_Call struct {
+ *mock.Call
+}
+
+// ParseQuery is a helper method to define mock.On call
+// - query string
+func (_e *MockPlcTagHandler_Expecter) ParseQuery(query interface{}) *MockPlcTagHandler_ParseQuery_Call {
+ return &MockPlcTagHandler_ParseQuery_Call{Call: _e.mock.On("ParseQuery", query)}
+}
+
+func (_c *MockPlcTagHandler_ParseQuery_Call) Run(run func(query string)) *MockPlcTagHandler_ParseQuery_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcTagHandler_ParseQuery_Call) Return(_a0 model.PlcQuery, _a1 error) *MockPlcTagHandler_ParseQuery_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockPlcTagHandler_ParseQuery_Call) RunAndReturn(run func(string) (model.PlcQuery, error)) *MockPlcTagHandler_ParseQuery_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ParseTag provides a mock function with given fields: tagAddress
+func (_m *MockPlcTagHandler) ParseTag(tagAddress string) (model.PlcTag, error) {
+ ret := _m.Called(tagAddress)
+
+ var r0 model.PlcTag
+ var r1 error
+ if rf, ok := ret.Get(0).(func(string) (model.PlcTag, error)); ok {
+ return rf(tagAddress)
+ }
+ if rf, ok := ret.Get(0).(func(string) model.PlcTag); ok {
+ r0 = rf(tagAddress)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcTag)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(string) error); ok {
+ r1 = rf(tagAddress)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockPlcTagHandler_ParseTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParseTag'
+type MockPlcTagHandler_ParseTag_Call struct {
+ *mock.Call
+}
+
+// ParseTag is a helper method to define mock.On call
+// - tagAddress string
+func (_e *MockPlcTagHandler_Expecter) ParseTag(tagAddress interface{}) *MockPlcTagHandler_ParseTag_Call {
+ return &MockPlcTagHandler_ParseTag_Call{Call: _e.mock.On("ParseTag", tagAddress)}
+}
+
+func (_c *MockPlcTagHandler_ParseTag_Call) Run(run func(tagAddress string)) *MockPlcTagHandler_ParseTag_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcTagHandler_ParseTag_Call) Return(_a0 model.PlcTag, _a1 error) *MockPlcTagHandler_ParseTag_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockPlcTagHandler_ParseTag_Call) RunAndReturn(run func(string) (model.PlcTag, error)) *MockPlcTagHandler_ParseTag_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcTagHandler interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcTagHandler creates a new instance of MockPlcTagHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcTagHandler(t mockConstructorTestingTNewMockPlcTagHandler) *MockPlcTagHandler {
+ mock := &MockPlcTagHandler{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/mock_TransportInstance_test.go b/plc4go/spi/default/mock_TransportInstance_test.go
new file mode 100644
index 0000000000..04f1eae423
--- /dev/null
+++ b/plc4go/spi/default/mock_TransportInstance_test.go
@@ -0,0 +1,506 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.26.1. DO NOT EDIT.
+
+package _default
+
+import (
+ bufio "bufio"
+ context "context"
+
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockTransportInstance is an autogenerated mock type for the TransportInstance type
+type MockTransportInstance struct {
+ mock.Mock
+}
+
+type MockTransportInstance_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockTransportInstance) EXPECT() *MockTransportInstance_Expecter {
+ return &MockTransportInstance_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with given fields:
+func (_m *MockTransportInstance) Close() error {
+ ret := _m.Called()
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func() error); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockTransportInstance_Close_Call struct {
+ *mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockTransportInstance_Expecter) Close() *MockTransportInstance_Close_Call {
+ return &MockTransportInstance_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockTransportInstance_Close_Call) Run(run func()) *MockTransportInstance_Close_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_Close_Call) Return(_a0 error) *MockTransportInstance_Close_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_Close_Call) RunAndReturn(run func() error) *MockTransportInstance_Close_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Connect provides a mock function with given fields:
+func (_m *MockTransportInstance) Connect() error {
+ ret := _m.Called()
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func() error); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
+type MockTransportInstance_Connect_Call struct {
+ *mock.Call
+}
+
+// Connect is a helper method to define mock.On call
+func (_e *MockTransportInstance_Expecter) Connect() *MockTransportInstance_Connect_Call {
+ return &MockTransportInstance_Connect_Call{Call: _e.mock.On("Connect")}
+}
+
+func (_c *MockTransportInstance_Connect_Call) Run(run func()) *MockTransportInstance_Connect_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_Connect_Call) Return(_a0 error) *MockTransportInstance_Connect_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_Connect_Call) RunAndReturn(run func() error) *MockTransportInstance_Connect_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ConnectWithContext provides a mock function with given fields: ctx
+func (_m *MockTransportInstance) ConnectWithContext(ctx context.Context) error {
+ ret := _m.Called(ctx)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context) error); ok {
+ r0 = rf(ctx)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_ConnectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectWithContext'
+type MockTransportInstance_ConnectWithContext_Call struct {
+ *mock.Call
+}
+
+// ConnectWithContext is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockTransportInstance_Expecter) ConnectWithContext(ctx interface{}) *MockTransportInstance_ConnectWithContext_Call {
+ return &MockTransportInstance_ConnectWithContext_Call{Call: _e.mock.On("ConnectWithContext", ctx)}
+}
+
+func (_c *MockTransportInstance_ConnectWithContext_Call) Run(run func(ctx context.Context)) *MockTransportInstance_ConnectWithContext_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_ConnectWithContext_Call) Return(_a0 error) *MockTransportInstance_ConnectWithContext_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_ConnectWithContext_Call) RunAndReturn(run func(context.Context) error) *MockTransportInstance_ConnectWithContext_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// FillBuffer provides a mock function with given fields: until
+func (_m *MockTransportInstance) FillBuffer(until func(uint, byte, *bufio.Reader) bool) error {
+ ret := _m.Called(until)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(func(uint, byte, *bufio.Reader) bool) error); ok {
+ r0 = rf(until)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_FillBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FillBuffer'
+type MockTransportInstance_FillBuffer_Call struct {
+ *mock.Call
+}
+
+// FillBuffer is a helper method to define mock.On call
+// - until func(uint , byte , *bufio.Reader) bool
+func (_e *MockTransportInstance_Expecter) FillBuffer(until interface{}) *MockTransportInstance_FillBuffer_Call {
+ return &MockTransportInstance_FillBuffer_Call{Call: _e.mock.On("FillBuffer", until)}
+}
+
+func (_c *MockTransportInstance_FillBuffer_Call) Run(run func(until func(uint, byte, *bufio.Reader) bool)) *MockTransportInstance_FillBuffer_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(func(uint, byte, *bufio.Reader) bool))
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_FillBuffer_Call) Return(_a0 error) *MockTransportInstance_FillBuffer_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_FillBuffer_Call) RunAndReturn(run func(func(uint, byte, *bufio.Reader) bool) error) *MockTransportInstance_FillBuffer_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetNumBytesAvailableInBuffer provides a mock function with given fields:
+func (_m *MockTransportInstance) GetNumBytesAvailableInBuffer() (uint32, error) {
+ ret := _m.Called()
+
+ var r0 uint32
+ var r1 error
+ if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+ return rf()
+ }
+ if rf, ok := ret.Get(0).(func() uint32); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(uint32)
+ }
+
+ if rf, ok := ret.Get(1).(func() error); ok {
+ r1 = rf()
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockTransportInstance_GetNumBytesAvailableInBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNumBytesAvailableInBuffer'
+type MockTransportInstance_GetNumBytesAvailableInBuffer_Call struct {
+ *mock.Call
+}
+
+// GetNumBytesAvailableInBuffer is a helper method to define mock.On call
+func (_e *MockTransportInstance_Expecter) GetNumBytesAvailableInBuffer() *MockTransportInstance_GetNumBytesAvailableInBuffer_Call {
+ return &MockTransportInstance_GetNumBytesAvailableInBuffer_Call{Call: _e.mock.On("GetNumBytesAvailableInBuffer")}
+}
+
+func (_c *MockTransportInstance_GetNumBytesAvailableInBuffer_Call) Run(run func()) *MockTransportInstance_GetNumBytesAvailableInBuffer_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_GetNumBytesAvailableInBuffer_Call) Return(_a0 uint32, _a1 error) *MockTransportInstance_GetNumBytesAvailableInBuffer_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockTransportInstance_GetNumBytesAvailableInBuffer_Call) RunAndReturn(run func() (uint32, error)) *MockTransportInstance_GetNumBytesAvailableInBuffer_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsConnected provides a mock function with given fields:
+func (_m *MockTransportInstance) IsConnected() bool {
+ ret := _m.Called()
+
+ var r0 bool
+ if rf, ok := ret.Get(0).(func() bool); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(bool)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_IsConnected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsConnected'
+type MockTransportInstance_IsConnected_Call struct {
+ *mock.Call
+}
+
+// IsConnected is a helper method to define mock.On call
+func (_e *MockTransportInstance_Expecter) IsConnected() *MockTransportInstance_IsConnected_Call {
+ return &MockTransportInstance_IsConnected_Call{Call: _e.mock.On("IsConnected")}
+}
+
+func (_c *MockTransportInstance_IsConnected_Call) Run(run func()) *MockTransportInstance_IsConnected_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_IsConnected_Call) Return(_a0 bool) *MockTransportInstance_IsConnected_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_IsConnected_Call) RunAndReturn(run func() bool) *MockTransportInstance_IsConnected_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// PeekReadableBytes provides a mock function with given fields: numBytes
+func (_m *MockTransportInstance) PeekReadableBytes(numBytes uint32) ([]byte, error) {
+ ret := _m.Called(numBytes)
+
+ var r0 []byte
+ var r1 error
+ if rf, ok := ret.Get(0).(func(uint32) ([]byte, error)); ok {
+ return rf(numBytes)
+ }
+ if rf, ok := ret.Get(0).(func(uint32) []byte); ok {
+ r0 = rf(numBytes)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]byte)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(uint32) error); ok {
+ r1 = rf(numBytes)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockTransportInstance_PeekReadableBytes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PeekReadableBytes'
+type MockTransportInstance_PeekReadableBytes_Call struct {
+ *mock.Call
+}
+
+// PeekReadableBytes is a helper method to define mock.On call
+// - numBytes uint32
+func (_e *MockTransportInstance_Expecter) PeekReadableBytes(numBytes interface{}) *MockTransportInstance_PeekReadableBytes_Call {
+ return &MockTransportInstance_PeekReadableBytes_Call{Call: _e.mock.On("PeekReadableBytes", numBytes)}
+}
+
+func (_c *MockTransportInstance_PeekReadableBytes_Call) Run(run func(numBytes uint32)) *MockTransportInstance_PeekReadableBytes_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(uint32))
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_PeekReadableBytes_Call) Return(_a0 []byte, _a1 error) *MockTransportInstance_PeekReadableBytes_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockTransportInstance_PeekReadableBytes_Call) RunAndReturn(run func(uint32) ([]byte, error)) *MockTransportInstance_PeekReadableBytes_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Read provides a mock function with given fields: numBytes
+func (_m *MockTransportInstance) Read(numBytes uint32) ([]byte, error) {
+ ret := _m.Called(numBytes)
+
+ var r0 []byte
+ var r1 error
+ if rf, ok := ret.Get(0).(func(uint32) ([]byte, error)); ok {
+ return rf(numBytes)
+ }
+ if rf, ok := ret.Get(0).(func(uint32) []byte); ok {
+ r0 = rf(numBytes)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]byte)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(uint32) error); ok {
+ r1 = rf(numBytes)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// MockTransportInstance_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
+type MockTransportInstance_Read_Call struct {
+ *mock.Call
+}
+
+// Read is a helper method to define mock.On call
+// - numBytes uint32
+func (_e *MockTransportInstance_Expecter) Read(numBytes interface{}) *MockTransportInstance_Read_Call {
+ return &MockTransportInstance_Read_Call{Call: _e.mock.On("Read", numBytes)}
+}
+
+func (_c *MockTransportInstance_Read_Call) Run(run func(numBytes uint32)) *MockTransportInstance_Read_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(uint32))
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_Read_Call) Return(_a0 []byte, _a1 error) *MockTransportInstance_Read_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *MockTransportInstance_Read_Call) RunAndReturn(run func(uint32) ([]byte, error)) *MockTransportInstance_Read_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// String provides a mock function with given fields:
+func (_m *MockTransportInstance) String() string {
+ ret := _m.Called()
+
+ var r0 string
+ if rf, ok := ret.Get(0).(func() string); ok {
+ r0 = rf()
+ } else {
+ r0 = ret.Get(0).(string)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type MockTransportInstance_String_Call struct {
+ *mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *MockTransportInstance_Expecter) String() *MockTransportInstance_String_Call {
+ return &MockTransportInstance_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *MockTransportInstance_String_Call) Run(run func()) *MockTransportInstance_String_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_String_Call) Return(_a0 string) *MockTransportInstance_String_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_String_Call) RunAndReturn(run func() string) *MockTransportInstance_String_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Write provides a mock function with given fields: data
+func (_m *MockTransportInstance) Write(data []byte) error {
+ ret := _m.Called(data)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func([]byte) error); ok {
+ r0 = rf(data)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// MockTransportInstance_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
+type MockTransportInstance_Write_Call struct {
+ *mock.Call
+}
+
+// Write is a helper method to define mock.On call
+// - data []byte
+func (_e *MockTransportInstance_Expecter) Write(data interface{}) *MockTransportInstance_Write_Call {
+ return &MockTransportInstance_Write_Call{Call: _e.mock.On("Write", data)}
+}
+
+func (_c *MockTransportInstance_Write_Call) Run(run func(data []byte)) *MockTransportInstance_Write_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].([]byte))
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_Write_Call) Return(_a0 error) *MockTransportInstance_Write_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockTransportInstance_Write_Call) RunAndReturn(run func([]byte) error) *MockTransportInstance_Write_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockTransportInstance interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockTransportInstance creates a new instance of MockTransportInstance. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockTransportInstance(t mockConstructorTestingTNewMockTransportInstance) *MockTransportInstance {
+ mock := &MockTransportInstance{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/default/testDriver_test.go b/plc4go/spi/default/mock_requirements.go
similarity index 53%
rename from plc4go/spi/default/testDriver_test.go
rename to plc4go/spi/default/mock_requirements.go
index c2a347a627..315be18e86 100644
--- a/plc4go/spi/default/testDriver_test.go
+++ b/plc4go/spi/default/mock_requirements.go
@@ -20,23 +20,46 @@
package _default
import (
- "context"
- "net/url"
-
plc4go "github.com/apache/plc4x/plc4go/pkg/api"
apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
- "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/apache/plc4x/plc4go/spi"
"github.com/apache/plc4x/plc4go/spi/transports"
)
-// TODO: replace with proper mock
-type testDriver struct {
+// Note this file is a Helper for mockery to generate use mocks from other package
+
+// Deprecated: don't use it in productive code
+type PlcConnection interface {
+ plc4go.PlcConnection
+}
+
+// Deprecated: don't use it in productive code
+type Message interface {
+ spi.Message
+}
+
+// Deprecated: don't use it in productive code
+type MessageCodec interface {
+ spi.MessageCodec
+ spi.TransportInstanceExposer
+}
+
+// Deprecated: don't use it in productive code
+type PlcQuery interface {
+ apiModel.PlcQuery
+}
+
+// Deprecated: don't use it in productive code
+type PlcTagHandler interface {
+ spi.PlcTagHandler
}
-func (testDriver) GetConnectionWithContext(ctx context.Context, transportUrl url.URL, transports map[string]transports.Transport, options map[string][]string) <-chan plc4go.PlcConnectionConnectResult {
- return nil
+// Deprecated: don't use it in productive code
+type TransportInstance interface {
+ transports.TransportInstance
}
-func (testDriver) DiscoverWithContext(callback context.Context, event func(event apiModel.PlcDiscoveryItem), discoveryOptions ...options.WithDiscoveryOption) error {
- return nil
+// Deprecated: don't use it in productive code
+type PlcConnectionConnectResult interface {
+ plc4go.PlcConnectionConnectResult
}
diff --git a/plc4go/spi/default/testBrowser_test.go b/plc4go/spi/default/testBrowser_test.go
deleted file mode 100644
index ad1fe971d5..0000000000
--- a/plc4go/spi/default/testBrowser_test.go
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-import (
- "context"
-
- apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
-)
-
-// TODO: replace with proper mock
-type testBrowser struct {
- dispatcher func(ctx context.Context, interceptor func(result apiModel.PlcBrowseItem) bool, queryName string, query apiModel.PlcQuery) (apiModel.PlcResponseCode, []apiModel.PlcBrowseItem)
-}
-
-func (t testBrowser) BrowseQuery(ctx context.Context, interceptor func(result apiModel.PlcBrowseItem) bool, queryName string, query apiModel.PlcQuery) (apiModel.PlcResponseCode, []apiModel.PlcBrowseItem) {
- if t.dispatcher != nil {
- return t.dispatcher(ctx, interceptor, queryName, query)
- }
- interceptor(nil)
- return apiModel.PlcResponseCode_OK, nil
-}
diff --git a/plc4go/spi/default/testConnection_test.go b/plc4go/spi/default/testConnection_test.go
deleted file mode 100644
index 66a36a6b75..0000000000
--- a/plc4go/spi/default/testConnection_test.go
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-import (
- "context"
- plc4go "github.com/apache/plc4x/plc4go/pkg/api"
- "github.com/apache/plc4x/plc4go/pkg/api/model"
- "github.com/apache/plc4x/plc4go/spi"
-)
-
-// TODO: replace with proper mock
-type testConnection struct {
- testMessageCodec testMessageCodec
- connected bool
-}
-
-func (t testConnection) Connect() <-chan plc4go.PlcConnectionConnectResult {
- return t.ConnectWithContext(nil)
-}
-
-func (t testConnection) BlockingClose() {
- // NO-OP
-}
-
-func (t testConnection) Close() <-chan plc4go.PlcConnectionCloseResult {
- // NO-OP
- return nil
-}
-
-func (t testConnection) IsConnected() bool {
- return t.connected
-}
-
-func (t testConnection) Ping() <-chan plc4go.PlcConnectionPingResult {
- // NO-OP
- return nil
-}
-
-func (t testConnection) GetMetadata() model.PlcConnectionMetadata {
- // NO-OP
- return nil
-}
-
-func (t testConnection) ReadRequestBuilder() model.PlcReadRequestBuilder {
- // NO-OP
- return nil
-}
-
-func (t testConnection) WriteRequestBuilder() model.PlcWriteRequestBuilder {
- // NO-OP
- return nil
-}
-
-func (t testConnection) SubscriptionRequestBuilder() model.PlcSubscriptionRequestBuilder {
- // NO-OP
- return nil
-}
-
-func (t testConnection) UnsubscriptionRequestBuilder() model.PlcUnsubscriptionRequestBuilder {
- // NO-OP
- return nil
-}
-
-func (t testConnection) BrowseRequestBuilder() model.PlcBrowseRequestBuilder {
- // NO-OP
- return nil
-}
-
-func (t testConnection) GetConnection() plc4go.PlcConnection {
- // NO-OP
- return t
-}
-
-func (t testConnection) GetMessageCodec() spi.MessageCodec {
- return t.testMessageCodec
-}
-
-func (t testConnection) ConnectWithContext(_ context.Context) <-chan plc4go.PlcConnectionConnectResult {
- // NO-OP
- return nil
-}
diff --git a/plc4go/spi/default/testMessageCodec_test.go b/plc4go/spi/default/testMessageCodec_test.go
deleted file mode 100644
index 000ef4286e..0000000000
--- a/plc4go/spi/default/testMessageCodec_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-import (
- "context"
- "github.com/apache/plc4x/plc4go/spi/transports"
-
- "github.com/apache/plc4x/plc4go/spi"
- "time"
-)
-
-// TODO: replace with proper mock
-type testMessageCodec struct {
- receive func() (spi.Message, error)
- send func(message spi.Message) error
-}
-
-func (t testMessageCodec) Connect() error {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) ConnectWithContext(ctx context.Context) error {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) Disconnect() error {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) IsRunning() bool {
- // NO-OP
- return false
-}
-
-func (t testMessageCodec) Send(message spi.Message) error {
- if t.send != nil {
- return t.send(message)
- }
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) Expect(ctx context.Context, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration) error {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) SendRequest(ctx context.Context, message spi.Message, acceptsMessage spi.AcceptsMessage, handleMessage spi.HandleMessage, handleError spi.HandleError, ttl time.Duration) error {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) GetDefaultIncomingMessageChannel() chan spi.Message {
- // NO-OP
- return nil
-}
-
-func (t testMessageCodec) GetTransportInstance() transports.TransportInstance {
- return testTransportInstance{}
-}
-
-func (t testMessageCodec) GetCodec() spi.MessageCodec {
- return t
-}
-
-func (t testMessageCodec) Receive() (spi.Message, error) {
- if t.receive != nil {
- return t.receive()
- }
- // NO-OP
- return nil, nil
-}
diff --git a/plc4go/spi/default/testMessage_test.go b/plc4go/spi/default/testMessage_test.go
deleted file mode 100644
index dd55c40013..0000000000
--- a/plc4go/spi/default/testMessage_test.go
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-import (
- "context"
- "github.com/apache/plc4x/plc4go/spi/utils"
-)
-
-// TODO: replace with proper mock
-type testMessage struct {
-}
-
-func (testMessage) Serialize() ([]byte, error) {
- // NO-OP
- return nil, nil
-}
-
-func (testMessage) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
- // NO-OP
- return nil
-}
-
-func (testMessage) GetLengthInBytes(ctx context.Context) uint16 {
- // NO-OP
- return 0
-}
-
-func (testMessage) GetLengthInBits(ctx context.Context) uint16 {
- // NO-OP
- return 0
-}
diff --git a/plc4go/spi/default/testQuery_test.go b/plc4go/spi/default/testQuery_test.go
deleted file mode 100644
index f4605157fd..0000000000
--- a/plc4go/spi/default/testQuery_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-// TODO: replace with proper mock
-type testQuery struct {
-}
-
-func (testQuery) GetQueryString() string {
- return "blub"
-}
diff --git a/plc4go/spi/default/testTagHandler_test.go b/plc4go/spi/default/testTagHandler_test.go
deleted file mode 100644
index 2d0c0e0019..0000000000
--- a/plc4go/spi/default/testTagHandler_test.go
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package _default
-
-import apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
-
-// TODO: replace with proper mock
-type testTagHandler struct {
-}
-
-func (testTagHandler) ParseTag(tagAddress string) (apiModel.PlcTag, error) {
- return nil, nil
-}
-
-func (testTagHandler) ParseQuery(query string) (apiModel.PlcQuery, error) {
- return nil, nil
-}
diff --git a/plc4go/spi/transports/TransportInstance.go b/plc4go/spi/transports/TransportInstance.go
index 34005e3c24..fc3b66d328 100644
--- a/plc4go/spi/transports/TransportInstance.go
+++ b/plc4go/spi/transports/TransportInstance.go
@@ -72,7 +72,7 @@ func (m *defaultBufferedTransportInstance) ConnectWithContext(ctx context.Contex
go func() {
defer func() {
if err := recover(); err != nil {
- log.Fatal().Interface("err", err).Msg("connect panic-ed")
+ log.Error().Interface("err", err).Msg("connect panic-ed")
}
}()
ch <- m.Connect()
diff --git a/plc4go/spi/utils/Net.go b/plc4go/spi/utils/Net.go
index ec76328cdb..a166a21213 100644
--- a/plc4go/spi/utils/Net.go
+++ b/plc4go/spi/utils/Net.go
@@ -145,11 +145,10 @@ func lockupIpsUsingArp(ctx context.Context, netInterface net.Interface, ipNet *n
log.Trace().Msgf("Scheduling discovery for IP %s", ip)
timeout := time.NewTimer(2 * time.Second)
go func(ip net.IP) {
+ defer CleanupTimer(timeout)
select {
case <-ctx.Done():
- CleanupTimer(timeout)
case foundIps <- DuplicateIP(ip):
- CleanupTimer(timeout)
case <-timeout.C:
}
}(DuplicateIP(ip))
@@ -232,11 +231,10 @@ func lookupIps(ctx context.Context, ipnet *net.IPNet, foundIps chan net.IP, wg *
timeout := time.NewTimer(2 * time.Second)
go func(ip net.IP) {
defer func() { wg.Done() }()
+ defer CleanupTimer(timeout)
select {
case <-ctx.Done():
- CleanupTimer(timeout)
case foundIps <- ip:
- CleanupTimer(timeout)
case <-timeout.C:
}
}(DuplicateIP(ip))
[plc4x] 01/02: test(plc4go/spi): replace temp mock with mockery mock in write buffer
Posted by sr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit c889e477b830ab3d48d1a57f212f80a61432bda6
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue May 9 13:43:13 2023 +0200
test(plc4go/spi): replace temp mock with mockery mock in write buffer
---
plc4go/spi/utils/WriteBufferByteBased_test.go | 18 ++++++------------
1 file changed, 6 insertions(+), 12 deletions(-)
diff --git a/plc4go/spi/utils/WriteBufferByteBased_test.go b/plc4go/spi/utils/WriteBufferByteBased_test.go
index 475824f6bd..be1916ad7d 100644
--- a/plc4go/spi/utils/WriteBufferByteBased_test.go
+++ b/plc4go/spi/utils/WriteBufferByteBased_test.go
@@ -25,6 +25,7 @@ import (
"encoding/binary"
"fmt"
"github.com/icza/bitio"
+ "github.com/stretchr/testify/mock"
"math/big"
"testing"
@@ -842,17 +843,6 @@ func Test_byteWriteBuffer_WriteInt8(t *testing.T) {
}
}
-type _Test_byteWriteBuffer_WriteSerializable_Serializable struct {
-}
-
-func (_Test_byteWriteBuffer_WriteSerializable_Serializable) Serialize() ([]byte, error) {
- return nil, nil
-}
-
-func (_Test_byteWriteBuffer_WriteSerializable_Serializable) SerializeWithWriteBuffer(ctx context.Context, writeBuffer WriteBuffer) error {
- return nil
-}
-
func Test_byteWriteBuffer_WriteSerializable(t *testing.T) {
type fields struct {
data *bytes.Buffer
@@ -883,7 +873,11 @@ func Test_byteWriteBuffer_WriteSerializable(t *testing.T) {
writer: bitio.NewWriter(new(bytes.Buffer)),
},
args: args{
- serializable: _Test_byteWriteBuffer_WriteSerializable_Serializable{},
+ serializable: func() Serializable {
+ serializable := NewMockSerializable(t)
+ serializable.EXPECT().SerializeWithWriteBuffer(mock.Anything, mock.Anything).Return(nil)
+ return serializable
+ }(),
},
wantErr: assert.NoError,
},