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/08 17:29:56 UTC
[plc4x] branch develop updated: test(plc4go/spi): replace temp mock with mockery mock
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
The following commit(s) were added to refs/heads/develop by this push:
new 5777c182ba test(plc4go/spi): replace temp mock with mockery mock
5777c182ba is described below
commit 5777c182ba51c566b405cbbd1ecde3fbacc4e094
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Mon May 8 15:53:50 2023 +0200
test(plc4go/spi): replace temp mock with mockery mock
---
plc4go/spi/RequestTransactionManager_test.go | 93 ++-
.../SingleItemRequestInterceptor_test.go | 781 ++++++++++-----------
.../interceptors/mock_PlcReadRequestResult_test.go | 182 +++++
.../spi/interceptors/mock_PlcReadRequest_test.go | 401 +++++++++++
.../spi/interceptors/mock_PlcReadResponse_test.go | 311 ++++++++
.../mock_PlcWriteRequestResult_test.go | 182 +++++
.../spi/interceptors/mock_PlcWriteRequest_test.go | 447 ++++++++++++
.../spi/interceptors/mock_PlcWriteResponse_test.go | 265 +++++++
plc4go/spi/interceptors/mock_requirements.go | 60 ++
plc4go/spi/mock_CompletionFuture_test.go | 132 ++++
plc4go/spi/mock_requirements.go | 31 +
11 files changed, 2437 insertions(+), 448 deletions(-)
diff --git a/plc4go/spi/RequestTransactionManager_test.go b/plc4go/spi/RequestTransactionManager_test.go
index 29b6e52cdd..82b03a269b 100644
--- a/plc4go/spi/RequestTransactionManager_test.go
+++ b/plc4go/spi/RequestTransactionManager_test.go
@@ -25,6 +25,7 @@ import (
"github.com/apache/plc4x/plc4go/spi/utils"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
"testing"
"time"
)
@@ -228,16 +229,6 @@ func Test_requestTransactionManager_endRequest(t *testing.T) {
}
}
-type _Test_requestTransactionManager_failRequest_CompletionFuture struct {
-}
-
-func (_Test_requestTransactionManager_failRequest_CompletionFuture) AwaitCompletion(ctx context.Context) error {
- return nil
-}
-
-func (_Test_requestTransactionManager_failRequest_CompletionFuture) Cancel(interrupt bool, err error) {
-}
-
func Test_requestTransactionManager_failRequest(t *testing.T) {
type fields struct {
runningRequests []*requestTransaction
@@ -251,23 +242,31 @@ func Test_requestTransactionManager_failRequest(t *testing.T) {
err error
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr bool
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr bool
}{
{
name: "fail a request",
args: args{
- transaction: &requestTransaction{
- completionFuture: _Test_requestTransactionManager_failRequest_CompletionFuture{},
- },
+ transaction: &requestTransaction{},
+ },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ completionFuture := NewMockCompletionFuture(t)
+ expect := completionFuture.EXPECT()
+ expect.Cancel(true, nil).Return()
+ args.transaction.completionFuture = completionFuture
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
r := &requestTransactionManager{
runningRequests: tt.fields.runningRequests,
numberOfConcurrentRequests: tt.fields.numberOfConcurrentRequests,
@@ -415,16 +414,6 @@ func Test_requestTransactionManager_submitTransaction(t *testing.T) {
}
}
-type _Test_requestTransaction_AwaitCompletion_CompletionFuture struct {
-}
-
-func (_Test_requestTransaction_AwaitCompletion_CompletionFuture) AwaitCompletion(ctx context.Context) error {
- return nil
-}
-
-func (_Test_requestTransaction_AwaitCompletion_CompletionFuture) Cancel(interrupt bool, err error) {
-}
-
func Test_requestTransaction_AwaitCompletion(t1 *testing.T) {
type fields struct {
parent *requestTransactionManager
@@ -437,10 +426,11 @@ func Test_requestTransaction_AwaitCompletion(t1 *testing.T) {
ctx context.Context
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr bool
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr bool
}{
{
name: "just wait",
@@ -458,7 +448,6 @@ func Test_requestTransaction_AwaitCompletion(t1 *testing.T) {
}(),
},
},
- completionFuture: _Test_requestTransaction_AwaitCompletion_CompletionFuture{},
},
args: args{
ctx: func() context.Context {
@@ -467,10 +456,19 @@ func Test_requestTransaction_AwaitCompletion(t1 *testing.T) {
return ctx
}(),
},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ completionFuture := NewMockCompletionFuture(t)
+ expect := completionFuture.EXPECT()
+ expect.AwaitCompletion(mock.Anything).Return(nil)
+ fields.completionFuture = completionFuture
+ },
},
}
for _, tt := range tests {
t1.Run(tt.name, func(t1 *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t1, &tt.fields, &tt.args)
+ }
t := &requestTransaction{
parent: tt.fields.parent,
transactionId: tt.fields.transactionId,
@@ -522,16 +520,6 @@ func Test_requestTransaction_EndRequest(t1 *testing.T) {
}
}
-type _Test_requestTransaction_FailRequest_CompletionFuture struct {
-}
-
-func (_Test_requestTransaction_FailRequest_CompletionFuture) AwaitCompletion(ctx context.Context) error {
- return nil
-}
-
-func (_Test_requestTransaction_FailRequest_CompletionFuture) Cancel(interrupt bool, err error) {
-}
-
func Test_requestTransaction_FailRequest(t1 *testing.T) {
type fields struct {
parent *requestTransactionManager
@@ -544,22 +532,31 @@ func Test_requestTransaction_FailRequest(t1 *testing.T) {
err error
}
tests := []struct {
- name string
- fields fields
- args args
- wantErr bool
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantErr bool
}{
{
name: "just fail it",
fields: fields{
- parent: &requestTransactionManager{},
- completionFuture: _Test_requestTransaction_FailRequest_CompletionFuture{},
+ parent: &requestTransactionManager{},
+ },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ completionFuture := NewMockCompletionFuture(t)
+ expect := completionFuture.EXPECT()
+ expect.Cancel(true, nil).Return()
+ fields.completionFuture = completionFuture
},
wantErr: true,
},
}
for _, tt := range tests {
t1.Run(tt.name, func(t1 *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t1, &tt.fields, &tt.args)
+ }
t := &requestTransaction{
parent: tt.fields.parent,
transactionId: tt.fields.transactionId,
diff --git a/plc4go/spi/interceptors/SingleItemRequestInterceptor_test.go b/plc4go/spi/interceptors/SingleItemRequestInterceptor_test.go
index d5f7ea433b..bf17dd825f 100644
--- a/plc4go/spi/interceptors/SingleItemRequestInterceptor_test.go
+++ b/plc4go/spi/interceptors/SingleItemRequestInterceptor_test.go
@@ -26,6 +26,7 @@ import (
"github.com/apache/plc4x/plc4go/spi"
"github.com/apache/plc4x/plc4go/spi/utils"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
"testing"
apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
@@ -57,122 +58,96 @@ func TestNewSingleItemRequestInterceptor(t *testing.T) {
}
}
-// TODO: replace with mock
-type _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest struct {
- _String string
- _IsAPlcMessage bool
- _Execute func() <-chan apiModel.PlcReadRequestResult
- _ExecuteWithContext func(ctx context.Context) <-chan apiModel.PlcReadRequestResult
- _GetTagNames []string
- _GetTag map[string]apiModel.PlcTag
- _GetReader spi.PlcReader
- _GetReadRequestInterceptor ReadRequestInterceptor
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) String() string {
- return t._String
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) IsAPlcMessage() bool {
- return t._IsAPlcMessage
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) Execute() <-chan apiModel.PlcReadRequestResult {
- return t._Execute()
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) ExecuteWithContext(ctx context.Context) <-chan apiModel.PlcReadRequestResult {
- return t._ExecuteWithContext(ctx)
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) GetTagNames() []string {
- return t._GetTagNames
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) GetTag(tagName string) apiModel.PlcTag {
- return t._GetTag[tagName]
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) GetReader() spi.PlcReader {
- return t._GetReader
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest) GetReadRequestInterceptor() ReadRequestInterceptor {
- return t._GetReadRequestInterceptor
-}
-
func TestSingleItemRequestInterceptor_InterceptReadRequest(t *testing.T) {
type fields struct {
- readRequestFactory readRequestFactory
- writeRequestFactory writeRequestFactory
- readResponseFactory readResponseFactory
- writeResponseFactory writeResponseFactory
+ readRequestFactory func(t *testing.T) readRequestFactory
+ writeRequestFactory func(t *testing.T) writeRequestFactory
+ readResponseFactory func(t *testing.T) readResponseFactory
+ writeResponseFactory func(t *testing.T) writeResponseFactory
}
type args struct {
ctx context.Context
readRequest apiModel.PlcReadRequest
}
tests := []struct {
- name string
- fields fields
- args args
- want []apiModel.PlcReadRequest
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantAssert func(t *testing.T, args args, got []apiModel.PlcReadRequest) bool
}{
{
name: "nil stays nil",
},
{
name: "read request with no tags",
- args: args{
- readRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ plcReadRequest.EXPECT().GetTagNames().Return(nil)
+ args.readRequest = plcReadRequest
},
},
{
name: "read request with 1 tag",
- args: args{
- readRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"a tag"},
- },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ plcReadRequest.EXPECT().GetTagNames().Return([]string{"a tag"})
+ args.readRequest = plcReadRequest
},
- want: []apiModel.PlcReadRequest{
- _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"a tag"},
- },
+ wantAssert: func(t *testing.T, args args, got []apiModel.PlcReadRequest) bool {
+ return assert.Contains(t, got, args.readRequest)
},
},
{
name: "read request with 2 tags",
fields: fields{
- readRequestFactory: func(tags map[string]apiModel.PlcTag, tagNames []string, _ spi.PlcReader, _ ReadRequestInterceptor) apiModel.PlcReadRequest {
- return _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: tagNames,
- _GetTag: tags,
+ readRequestFactory: func(t *testing.T) readRequestFactory {
+ return func(tags map[string]apiModel.PlcTag, tagNames []string, _ spi.PlcReader, _ ReadRequestInterceptor) apiModel.PlcReadRequest {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ expect := plcReadRequest.EXPECT()
+ expect.GetTagNames().Return(tagNames)
+ expect.GetTag(mock.Anything).RunAndReturn(func(s string) apiModel.PlcTag {
+ return tags[s]
+ })
+ return plcReadRequest
}
},
},
args: args{
ctx: context.Background(),
- readRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"1 tag", "2 tag"},
- },
},
- want: []apiModel.PlcReadRequest{
- _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"1 tag"},
- _GetTag: map[string]apiModel.PlcTag{"1 tag": nil},
- }, _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"2 tag"},
- _GetTag: map[string]apiModel.PlcTag{"2 tag": nil},
- },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ expect := plcReadRequest.EXPECT()
+ expect.GetTagNames().Return([]string{"1 tag", "2 tag"})
+ expect.GetTag(mock.Anything).Return(nil)
+ expect.GetReader().Return(nil)
+ expect.GetReadRequestInterceptor().Return(nil)
+ args.readRequest = plcReadRequest
+ },
+ wantAssert: func(t *testing.T, args args, got []apiModel.PlcReadRequest) bool {
+ assert.Len(t, got, 2)
+ request1 := got[0]
+ assert.Len(t, request1.GetTagNames(), 1)
+ assert.Equal(t, nil, request1.GetTag(request1.GetTagNames()[0]))
+ request2 := got[1]
+ assert.Len(t, request2.GetTagNames(), 1)
+ assert.Equal(t, nil, request2.GetTag(request2.GetTagNames()[0]))
+ return true
},
},
{
name: "read request with 2 tags aborted",
fields: fields{
- readRequestFactory: func(tags map[string]apiModel.PlcTag, tagNames []string, _ spi.PlcReader, _ ReadRequestInterceptor) apiModel.PlcReadRequest {
- return _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: tagNames,
- _GetTag: tags,
+ readRequestFactory: func(t *testing.T) readRequestFactory {
+ return func(tags map[string]apiModel.PlcTag, tagNames []string, _ spi.PlcReader, _ ReadRequestInterceptor) apiModel.PlcReadRequest {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ expect := plcReadRequest.EXPECT()
+ expect.GetTagNames().Return(tagNames)
+ expect.GetTag(mock.Anything).RunAndReturn(func(s string) apiModel.PlcTag {
+ return tags[s]
+ })
+ return plcReadRequest
}
},
},
@@ -182,149 +157,149 @@ func TestSingleItemRequestInterceptor_InterceptReadRequest(t *testing.T) {
cancelFunc()
return ctx
}(),
- readRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{
- _GetTagNames: []string{"1 tag", "2 tag"},
- },
},
- want: nil,
+ wantAssert: func(t *testing.T, args args, got []apiModel.PlcReadRequest) bool {
+ return true
+ },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcReadRequest := NewMockPlcReadRequest(t)
+ plcReadRequest.EXPECT().GetTagNames().Return([]string{"1 tag", "2 tag"})
+ args.readRequest = plcReadRequest
+ },
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
+ if tt.fields.readRequestFactory == nil {
+ tt.fields.readRequestFactory = func(t *testing.T) readRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeRequestFactory == nil {
+ tt.fields.writeRequestFactory = func(t *testing.T) writeRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.readResponseFactory == nil {
+ tt.fields.readResponseFactory = func(t *testing.T) readResponseFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeResponseFactory == nil {
+ tt.fields.writeResponseFactory = func(t *testing.T) writeResponseFactory {
+ return nil
+ }
+ }
+ if tt.wantAssert == nil {
+ tt.wantAssert = func(t *testing.T, args args, got []apiModel.PlcReadRequest) bool {
+ return true
+ }
+ }
m := SingleItemRequestInterceptor{
- readRequestFactory: tt.fields.readRequestFactory,
- writeRequestFactory: tt.fields.writeRequestFactory,
- readResponseFactory: tt.fields.readResponseFactory,
- writeResponseFactory: tt.fields.writeResponseFactory,
+ readRequestFactory: tt.fields.readRequestFactory(t),
+ writeRequestFactory: tt.fields.writeRequestFactory(t),
+ readResponseFactory: tt.fields.readResponseFactory(t),
+ writeResponseFactory: tt.fields.writeResponseFactory(t),
}
- if got := m.InterceptReadRequest(tt.args.ctx, tt.args.readRequest); !assert.Equal(t, tt.want, got) {
- t.Errorf("InterceptReadRequest() = %v, want %v", got, tt.want)
+ if got := m.InterceptReadRequest(tt.args.ctx, tt.args.readRequest); !assert.True(t, tt.wantAssert(t, tt.args, got)) {
+ t.Errorf("InterceptReadRequest() = %v", got)
}
})
}
}
-// TODO: replace with mock
-type _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest struct {
- _String string
- _IsAPlcMessage bool
- _Execute func() <-chan apiModel.PlcWriteRequestResult
- _ExecuteWithContext func(ctx context.Context) <-chan apiModel.PlcWriteRequestResult
- _GetTagNames []string
- _GetTag map[string]apiModel.PlcTag
- _GetValue map[string]values.PlcValue
- _GetWriter spi.PlcWriter
- _GetWriteRequestInterceptor WriteRequestInterceptor
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) String() string {
- return t._String
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) IsAPlcMessage() bool {
- return t._IsAPlcMessage
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) Execute() <-chan apiModel.PlcWriteRequestResult {
- return t._Execute()
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) ExecuteWithContext(ctx context.Context) <-chan apiModel.PlcWriteRequestResult {
- return t._ExecuteWithContext(ctx)
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) GetTagNames() []string {
- return t._GetTagNames
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) GetTag(tagName string) apiModel.PlcTag {
- return t._GetTag[tagName]
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) GetValue(tagName string) values.PlcValue {
- return t._GetValue[tagName]
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) GetWriter() spi.PlcWriter {
- return t._GetWriter
-}
-
-func (t _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest) GetWriteRequestInterceptor() WriteRequestInterceptor {
- return t._GetWriteRequestInterceptor
-}
-
func TestSingleItemRequestInterceptor_InterceptWriteRequest(t *testing.T) {
type fields struct {
- readRequestFactory readRequestFactory
- writeRequestFactory writeRequestFactory
- readResponseFactory readResponseFactory
- writeResponseFactory writeResponseFactory
+ readRequestFactory func(t *testing.T) readRequestFactory
+ writeRequestFactory func(t *testing.T) writeRequestFactory
+ readResponseFactory func(t *testing.T) readResponseFactory
+ writeResponseFactory func(t *testing.T) writeResponseFactory
}
type args struct {
ctx context.Context
writeRequest apiModel.PlcWriteRequest
}
tests := []struct {
- name string
- fields fields
- args args
- want []apiModel.PlcWriteRequest
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantAssert func(t *testing.T, args args, got []apiModel.PlcWriteRequest) bool
}{
{
name: "nil stays nil",
},
{
- name: "read request with no tags",
- args: args{
- writeRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{},
+ name: "write request with no tags",
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ plcWriteRequest.EXPECT().GetTagNames().Return(nil)
+ args.writeRequest = plcWriteRequest
},
},
{
- name: "read request with 1 tag",
- args: args{
- writeRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"a tag"},
- },
+ name: "write request with 1 tag",
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ plcWriteRequest.EXPECT().GetTagNames().Return([]string{"a tag"})
+ args.writeRequest = plcWriteRequest
},
- want: []apiModel.PlcWriteRequest{
- _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"a tag"},
- },
+ wantAssert: func(t *testing.T, args args, got []apiModel.PlcWriteRequest) bool {
+ return assert.Contains(t, got, args.writeRequest)
},
},
{
- name: "read request with 2 tags",
+ name: "write request with 2 tags",
fields: fields{
- writeRequestFactory: func(tags map[string]apiModel.PlcTag, tagNames []string, values map[string]values.PlcValue, writer spi.PlcWriter, writeRequestInterceptor WriteRequestInterceptor) apiModel.PlcWriteRequest {
- return _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: tagNames,
- _GetTag: tags,
+ writeRequestFactory: func(t *testing.T) writeRequestFactory {
+ return func(tags map[string]apiModel.PlcTag, tagNames []string, values map[string]values.PlcValue, writer spi.PlcWriter, writeRequestInterceptor WriteRequestInterceptor) apiModel.PlcWriteRequest {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ expect := plcWriteRequest.EXPECT()
+ expect.GetTagNames().Return(tagNames)
+ expect.GetTag(mock.Anything).RunAndReturn(func(s string) apiModel.PlcTag {
+ return tags[s]
+ })
+ return plcWriteRequest
}
},
},
args: args{
ctx: context.Background(),
- writeRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"1 tag", "2 tag"},
- },
},
- want: []apiModel.PlcWriteRequest{
- _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"1 tag"},
- _GetTag: map[string]apiModel.PlcTag{"1 tag": nil},
- }, _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"2 tag"},
- _GetTag: map[string]apiModel.PlcTag{"2 tag": nil},
- },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ expect := plcWriteRequest.EXPECT()
+ expect.GetTagNames().Return([]string{"1 tag", "2 tag"})
+ expect.GetTag(mock.Anything).Return(nil)
+ expect.GetValue(mock.Anything).Return(nil)
+ expect.GetWriter().Return(nil)
+ expect.GetWriteRequestInterceptor().Return(nil)
+ args.writeRequest = plcWriteRequest
+ },
+ wantAssert: func(t *testing.T, args args, got []apiModel.PlcWriteRequest) bool {
+ assert.Len(t, got, 2)
+ assert.Contains(t, got[0].GetTagNames(), "1 tag")
+ assert.Nil(t, got[0].GetTag("1 tag"))
+ assert.Contains(t, got[1].GetTagNames(), "2 tag")
+ assert.Nil(t, got[1].GetTag("2 tag"))
+ return true
},
},
{
- name: "read request with 2 tags aborted",
+ name: "write request with 2 tags aborted",
fields: fields{
- writeRequestFactory: func(tags map[string]apiModel.PlcTag, tagNames []string, values map[string]values.PlcValue, writer spi.PlcWriter, writeRequestInterceptor WriteRequestInterceptor) apiModel.PlcWriteRequest {
- return _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: tagNames,
- _GetTag: tags,
+ writeRequestFactory: func(t *testing.T) writeRequestFactory {
+ return func(tags map[string]apiModel.PlcTag, tagNames []string, values map[string]values.PlcValue, writer spi.PlcWriter, writeRequestInterceptor WriteRequestInterceptor) apiModel.PlcWriteRequest {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ expect := plcWriteRequest.EXPECT()
+ expect.GetTagNames().Return(tagNames)
+ expect.GetTag(mock.Anything).RunAndReturn(func(s string) apiModel.PlcTag {
+ return tags[s]
+ })
+ return plcWriteRequest
}
},
},
@@ -334,86 +309,63 @@ func TestSingleItemRequestInterceptor_InterceptWriteRequest(t *testing.T) {
cancelFunc()
return ctx
}(),
- writeRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{
- _GetTagNames: []string{"1 tag", "2 tag"},
- },
},
- want: nil,
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ plcWriteRequest := NewMockPlcWriteRequest(t)
+ plcWriteRequest.EXPECT().GetTagNames().Return([]string{"1 tag", "2 tag"})
+ args.writeRequest = plcWriteRequest
+ },
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
+ if tt.fields.readRequestFactory == nil {
+ tt.fields.readRequestFactory = func(t *testing.T) readRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeRequestFactory == nil {
+ tt.fields.writeRequestFactory = func(t *testing.T) writeRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.readResponseFactory == nil {
+ tt.fields.readResponseFactory = func(t *testing.T) readResponseFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeResponseFactory == nil {
+ tt.fields.writeResponseFactory = func(t *testing.T) writeResponseFactory {
+ return nil
+ }
+ }
+ if tt.wantAssert == nil {
+ tt.wantAssert = func(t *testing.T, args args, got []apiModel.PlcWriteRequest) bool {
+ return true
+ }
+ }
m := SingleItemRequestInterceptor{
- readRequestFactory: tt.fields.readRequestFactory,
- writeRequestFactory: tt.fields.writeRequestFactory,
- readResponseFactory: tt.fields.readResponseFactory,
- writeResponseFactory: tt.fields.writeResponseFactory,
+ readRequestFactory: tt.fields.readRequestFactory(t),
+ writeRequestFactory: tt.fields.writeRequestFactory(t),
+ readResponseFactory: tt.fields.readResponseFactory(t),
+ writeResponseFactory: tt.fields.writeResponseFactory(t),
}
- if got := m.InterceptWriteRequest(tt.args.ctx, tt.args.writeRequest); !assert.Equal(t, tt.want, got) {
- t.Errorf("InterceptWriteRequest() = %v, want %v", got, tt.want)
+ if got := m.InterceptWriteRequest(tt.args.ctx, tt.args.writeRequest); !assert.True(t, tt.wantAssert(t, tt.args, got)) {
+ t.Errorf("InterceptWriteRequest() = %v", got)
}
})
}
}
-// TODO: replace with mock
-type _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult struct {
- _GetRequest apiModel.PlcReadRequest
- _GetResponse apiModel.PlcReadResponse
- _GetErr error
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult) GetRequest() apiModel.PlcReadRequest {
- return t._GetRequest
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult) GetResponse() apiModel.PlcReadResponse {
- return t._GetResponse
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult) GetErr() error {
- return t._GetErr
-}
-
-// TODO: replace with mock
-type _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse struct {
- _String string
- _GetRequest apiModel.PlcReadRequest
- _GetTagNames []string
- _GetResponseCode map[string]apiModel.PlcResponseCode
- _GetValue map[string]values.PlcValue
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) String() string {
- return t._String
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) IsAPlcMessage() bool {
- return true
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) GetRequest() apiModel.PlcReadRequest {
- return t._GetRequest
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) GetTagNames() []string {
- return t._GetTagNames
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) GetResponseCode(tagName string) apiModel.PlcResponseCode {
- return t._GetResponseCode[tagName]
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse) GetValue(tagName string) values.PlcValue {
- return t._GetValue[tagName]
-}
-
func TestSingleItemRequestInterceptor_ProcessReadResponses(t *testing.T) {
type fields struct {
- readRequestFactory readRequestFactory
- writeRequestFactory writeRequestFactory
- readResponseFactory readResponseFactory
- writeResponseFactory writeResponseFactory
+ readRequestFactory func(t *testing.T) readRequestFactory
+ writeRequestFactory func(t *testing.T) writeRequestFactory
+ readResponseFactory func(t *testing.T) readResponseFactory
+ writeResponseFactory func(t *testing.T) writeResponseFactory
}
type args struct {
ctx context.Context
@@ -421,73 +373,102 @@ func TestSingleItemRequestInterceptor_ProcessReadResponses(t *testing.T) {
readResults []apiModel.PlcReadRequestResult
}
tests := []struct {
- name string
- fields fields
- args args
- want apiModel.PlcReadRequestResult
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantAssert func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool
}{
{
name: "no results",
fields: fields{
- readResponseFactory: func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
- return nil
+ readResponseFactory: func(t *testing.T) readResponseFactory {
+ return func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
+ return nil
+ }
},
},
- want: &interceptedPlcReadRequestResult{},
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcReadRequestResult{}, got)
+ },
},
{
name: "one result",
- args: args{
- readResults: []apiModel.PlcReadRequestResult{
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{},
- },
- },
fields: fields{
- readResponseFactory: func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
- return nil
+ readResponseFactory: func(t *testing.T) readResponseFactory {
+ return func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
+ return nil
+ }
},
},
- want: _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ args.readResults = []apiModel.PlcReadRequestResult{
+ NewMockPlcReadRequestResult(t),
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return assert.Equal(t, NewMockPlcReadRequestResult(t), got)
+ },
},
{
name: "two result (bit empty)",
args: args{
ctx: context.Background(),
- readResults: []apiModel.PlcReadRequestResult{
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{},
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{},
- },
},
fields: fields{
- readResponseFactory: func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
- return nil
+ readResponseFactory: func(t *testing.T) readResponseFactory {
+ return func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
+ return nil
+ }
},
},
- want: &interceptedPlcReadRequestResult{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ result1 := NewMockPlcReadRequestResult(t)
+ result1Expect := result1.EXPECT()
+ result1Expect.GetResponse().Return(nil)
+ result1Expect.GetErr().Return(nil)
+ result2 := NewMockPlcReadRequestResult(t)
+ result2Expect := result2.EXPECT()
+ result2Expect.GetResponse().Return(nil)
+ result2Expect.GetErr().Return(nil)
+ args.readResults = []apiModel.PlcReadRequestResult{
+ result1,
+ result2,
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcReadRequestResult{}, got)
+ },
},
{
name: "two result",
args: args{
ctx: context.Background(),
- readResults: []apiModel.PlcReadRequestResult{
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{
- _GetErr: errors.New("asd"),
- },
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{},
- _GetResponse: _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{},
- },
- },
- },
},
fields: fields{
- readResponseFactory: func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
- return nil
+ readResponseFactory: func(t *testing.T) readResponseFactory {
+ return func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
+ return nil
+ }
},
},
- want: &interceptedPlcReadRequestResult{
- Err: utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{errors.New("asd")}},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ result1 := NewMockPlcReadRequestResult(t)
+ result1Expect := result1.EXPECT()
+ result1Expect.GetErr().Return(errors.New("asd"))
+ result2 := NewMockPlcReadRequestResult(t)
+ result2Expect := result2.EXPECT()
+ result2Expect.GetResponse().Return(nil)
+ result2Expect.GetErr().Return(nil)
+ args.readResults = []apiModel.PlcReadRequestResult{
+ result1,
+ result2,
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcReadRequestResult{
+ Err: utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{errors.New("asd")}},
+ }, got)
},
},
{
@@ -498,91 +479,70 @@ func TestSingleItemRequestInterceptor_ProcessReadResponses(t *testing.T) {
cancelFunc()
return ctx
}(),
- readResults: []apiModel.PlcReadRequestResult{
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{
- _GetErr: errors.New("asd"),
- },
- _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResult{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{},
- _GetResponse: _TestSingleItemRequestInterceptor_ProcessReadResponses_ReadResponse{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptReadRequestPlcReadRequest{},
- },
- },
- },
},
fields: fields{
- readResponseFactory: func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
- return nil
+ readResponseFactory: func(t *testing.T) readResponseFactory {
+ return func(request apiModel.PlcReadRequest, responseCodes map[string]apiModel.PlcResponseCode, values map[string]values.PlcValue) apiModel.PlcReadResponse {
+ return nil
+ }
},
},
- want: &interceptedPlcReadRequestResult{
- Err: errors.New("context canceled"),
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ args.readResults = []apiModel.PlcReadRequestResult{
+ NewMockPlcReadRequestResult(t),
+ NewMockPlcReadRequestResult(t),
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcReadRequestResult{
+ Err: errors.New("context canceled"),
+ }, got)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
+ if tt.fields.readRequestFactory == nil {
+ tt.fields.readRequestFactory = func(t *testing.T) readRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeRequestFactory == nil {
+ tt.fields.writeRequestFactory = func(t *testing.T) writeRequestFactory {
+ return nil
+ }
+ }
+ if tt.fields.readResponseFactory == nil {
+ tt.fields.readResponseFactory = func(t *testing.T) readResponseFactory {
+ return nil
+ }
+ }
+ if tt.fields.writeResponseFactory == nil {
+ tt.fields.writeResponseFactory = func(t *testing.T) writeResponseFactory {
+ return nil
+ }
+ }
+ if tt.wantAssert == nil {
+ tt.wantAssert = func(t *testing.T, args args, got apiModel.PlcReadRequestResult) bool {
+ return true
+ }
+ }
m := SingleItemRequestInterceptor{
- readRequestFactory: tt.fields.readRequestFactory,
- writeRequestFactory: tt.fields.writeRequestFactory,
- readResponseFactory: tt.fields.readResponseFactory,
- writeResponseFactory: tt.fields.writeResponseFactory,
+ readRequestFactory: tt.fields.readRequestFactory(t),
+ writeRequestFactory: tt.fields.writeRequestFactory(t),
+ readResponseFactory: tt.fields.readResponseFactory(t),
+ writeResponseFactory: tt.fields.writeResponseFactory(t),
}
- if got := m.ProcessReadResponses(tt.args.ctx, tt.args.readRequest, tt.args.readResults); !assert.Equal(t, tt.want, got) {
- t.Errorf("ProcessReadResponses() = %v, want %v", got, tt.want)
+ if got := m.ProcessReadResponses(tt.args.ctx, tt.args.readRequest, tt.args.readResults); !assert.True(t, tt.wantAssert(t, tt.args, got)) {
+ t.Errorf("ProcessReadResponses() = %v", got)
}
})
}
}
-// TODO: replace wioth mock
-type _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult struct {
- _GetRequest apiModel.PlcWriteRequest
- _GetResponse apiModel.PlcWriteResponse
- _GetErr error
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult) GetRequest() apiModel.PlcWriteRequest {
- return t._GetRequest
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult) GetResponse() apiModel.PlcWriteResponse {
- return t._GetResponse
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult) GetErr() error {
- return t._GetErr
-}
-
-// TODO: replace wioth mock
-type _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse struct {
- _String string
- _IsAPlcMessage bool
- _GetRequest apiModel.PlcWriteRequest
- _GetTagNames []string
- _GetResponseCode map[string]apiModel.PlcResponseCode
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse) String() string {
- return t._String
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse) IsAPlcMessage() bool {
- return t._IsAPlcMessage
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse) GetRequest() apiModel.PlcWriteRequest {
- return t._GetRequest
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse) GetTagNames() []string {
- return t._GetTagNames
-}
-
-func (t _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse) GetResponseCode(tagName string) apiModel.PlcResponseCode {
- return t._GetResponseCode[tagName]
-}
-
func TestSingleItemRequestInterceptor_ProcessWriteResponses(t *testing.T) {
type fields struct {
readRequestFactory readRequestFactory
@@ -596,10 +556,11 @@ func TestSingleItemRequestInterceptor_ProcessWriteResponses(t *testing.T) {
writeResults []apiModel.PlcWriteRequestResult
}
tests := []struct {
- name string
- fields fields
- args args
- want apiModel.PlcWriteRequestResult
+ name string
+ fields fields
+ args args
+ mockSetup func(t *testing.T, fields *fields, args *args)
+ wantAssert func(t *testing.T, args args, got apiModel.PlcWriteRequestResult) bool
}{
{
name: "no results",
@@ -608,61 +569,81 @@ func TestSingleItemRequestInterceptor_ProcessWriteResponses(t *testing.T) {
return nil
},
},
- want: &interceptedPlcWriteRequestResult{},
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcWriteRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcWriteRequestResult{}, got)
+ },
},
{
name: "one result",
- args: args{
- writeResults: []apiModel.PlcWriteRequestResult{
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{},
- },
- },
fields: fields{
writeResponseFactory: func(request apiModel.PlcWriteRequest, responseCodes map[string]apiModel.PlcResponseCode) apiModel.PlcWriteResponse {
return nil
},
},
- want: _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ args.writeResults = []apiModel.PlcWriteRequestResult{
+ NewMockPlcWriteRequestResult(t),
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcWriteRequestResult) bool {
+ return assert.Equal(t, NewMockPlcWriteRequestResult(t), got)
+ },
},
{
name: "two result (bit empty)",
- args: args{
- ctx: context.Background(),
- writeResults: []apiModel.PlcWriteRequestResult{
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{},
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{},
- },
- },
fields: fields{
writeResponseFactory: func(request apiModel.PlcWriteRequest, responseCodes map[string]apiModel.PlcResponseCode) apiModel.PlcWriteResponse {
return nil
},
},
- want: &interceptedPlcWriteRequestResult{},
+ args: args{
+ ctx: context.Background(),
+ },
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ result1 := NewMockPlcWriteRequestResult(t)
+ result1Expect := result1.EXPECT()
+ result1Expect.GetResponse().Return(nil)
+ result1Expect.GetErr().Return(nil)
+ result2 := NewMockPlcWriteRequestResult(t)
+ result2Expect := result2.EXPECT()
+ result2Expect.GetResponse().Return(nil)
+ result2Expect.GetErr().Return(nil)
+ args.writeResults = []apiModel.PlcWriteRequestResult{
+ result1,
+ result2,
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcWriteRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcWriteRequestResult{}, got)
+ },
},
{
name: "two result",
args: args{
ctx: context.Background(),
- writeResults: []apiModel.PlcWriteRequestResult{
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{
- _GetErr: errors.New("asd"),
- },
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{},
- _GetResponse: _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{},
- },
- },
- },
},
fields: fields{
writeResponseFactory: func(request apiModel.PlcWriteRequest, responseCodes map[string]apiModel.PlcResponseCode) apiModel.PlcWriteResponse {
return nil
},
},
- want: &interceptedPlcWriteRequestResult{
- Err: utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{errors.New("asd")}},
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ result1 := NewMockPlcWriteRequestResult(t)
+ result1Expect := result1.EXPECT()
+ result1Expect.GetErr().Return(errors.New("asd"))
+ result2 := NewMockPlcWriteRequestResult(t)
+ result2Expect := result2.EXPECT()
+ result2Expect.GetResponse().Return(nil)
+ result2Expect.GetErr().Return(nil)
+ args.writeResults = []apiModel.PlcWriteRequestResult{
+ result1,
+ result2,
+ }
+ },
+ wantAssert: func(t *testing.T, args args, got apiModel.PlcWriteRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcWriteRequestResult{
+ Err: utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{errors.New("asd")}},
+ }, got)
},
},
{
@@ -673,38 +654,38 @@ func TestSingleItemRequestInterceptor_ProcessWriteResponses(t *testing.T) {
cancelFunc()
return ctx
}(),
- writeResults: []apiModel.PlcWriteRequestResult{
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{
- _GetErr: errors.New("asd"),
- },
- _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResult{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{},
- _GetResponse: _TestSingleItemRequestInterceptor_ProcessWriteResponses_WriteResponse{
- _GetRequest: _TestSingleItemRequestInterceptor_InterceptWriteRequestPlcWriteRequest{},
- },
- },
- },
},
fields: fields{
writeResponseFactory: func(request apiModel.PlcWriteRequest, responseCodes map[string]apiModel.PlcResponseCode) apiModel.PlcWriteResponse {
return nil
},
},
- want: &interceptedPlcWriteRequestResult{
- Err: errors.New("context canceled"),
+ mockSetup: func(t *testing.T, fields *fields, args *args) {
+ args.writeResults = []apiModel.PlcWriteRequestResult{
+ NewMockPlcWriteRequestResult(t),
+ NewMockPlcWriteRequestResult(t),
+ }
+ },
+ wantAssert: func(t *testing.T, args args, want apiModel.PlcWriteRequestResult) bool {
+ return assert.Equal(t, &interceptedPlcWriteRequestResult{
+ Err: errors.New("context canceled"),
+ }, want)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
+ if tt.mockSetup != nil {
+ tt.mockSetup(t, &tt.fields, &tt.args)
+ }
m := SingleItemRequestInterceptor{
readRequestFactory: tt.fields.readRequestFactory,
writeRequestFactory: tt.fields.writeRequestFactory,
readResponseFactory: tt.fields.readResponseFactory,
writeResponseFactory: tt.fields.writeResponseFactory,
}
- if got := m.ProcessWriteResponses(tt.args.ctx, tt.args.writeRequest, tt.args.writeResults); !assert.Equal(t, tt.want, got) {
- t.Errorf("ProcessWriteResponses() = %v, want %v", got, tt.want)
+ if got := m.ProcessWriteResponses(tt.args.ctx, tt.args.writeRequest, tt.args.writeResults); !assert.True(t, tt.wantAssert(t, tt.args, got)) {
+ t.Errorf("ProcessWriteResponses() = %v", got)
}
})
}
diff --git a/plc4go/spi/interceptors/mock_PlcReadRequestResult_test.go b/plc4go/spi/interceptors/mock_PlcReadRequestResult_test.go
new file mode 100644
index 0000000000..face99e97d
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcReadRequestResult_test.go
@@ -0,0 +1,182 @@
+/*
+ * 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 interceptors
+
+import (
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockPlcReadRequestResult is an autogenerated mock type for the PlcReadRequestResult type
+type MockPlcReadRequestResult struct {
+ mock.Mock
+}
+
+type MockPlcReadRequestResult_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcReadRequestResult) EXPECT() *MockPlcReadRequestResult_Expecter {
+ return &MockPlcReadRequestResult_Expecter{mock: &_m.Mock}
+}
+
+// GetErr provides a mock function with given fields:
+func (_m *MockPlcReadRequestResult) 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
+}
+
+// MockPlcReadRequestResult_GetErr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetErr'
+type MockPlcReadRequestResult_GetErr_Call struct {
+ *mock.Call
+}
+
+// GetErr is a helper method to define mock.On call
+func (_e *MockPlcReadRequestResult_Expecter) GetErr() *MockPlcReadRequestResult_GetErr_Call {
+ return &MockPlcReadRequestResult_GetErr_Call{Call: _e.mock.On("GetErr")}
+}
+
+func (_c *MockPlcReadRequestResult_GetErr_Call) Run(run func()) *MockPlcReadRequestResult_GetErr_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetErr_Call) Return(_a0 error) *MockPlcReadRequestResult_GetErr_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetErr_Call) RunAndReturn(run func() error) *MockPlcReadRequestResult_GetErr_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetRequest provides a mock function with given fields:
+func (_m *MockPlcReadRequestResult) GetRequest() model.PlcReadRequest {
+ ret := _m.Called()
+
+ var r0 model.PlcReadRequest
+ if rf, ok := ret.Get(0).(func() model.PlcReadRequest); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcReadRequest)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequestResult_GetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRequest'
+type MockPlcReadRequestResult_GetRequest_Call struct {
+ *mock.Call
+}
+
+// GetRequest is a helper method to define mock.On call
+func (_e *MockPlcReadRequestResult_Expecter) GetRequest() *MockPlcReadRequestResult_GetRequest_Call {
+ return &MockPlcReadRequestResult_GetRequest_Call{Call: _e.mock.On("GetRequest")}
+}
+
+func (_c *MockPlcReadRequestResult_GetRequest_Call) Run(run func()) *MockPlcReadRequestResult_GetRequest_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetRequest_Call) Return(_a0 model.PlcReadRequest) *MockPlcReadRequestResult_GetRequest_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetRequest_Call) RunAndReturn(run func() model.PlcReadRequest) *MockPlcReadRequestResult_GetRequest_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetResponse provides a mock function with given fields:
+func (_m *MockPlcReadRequestResult) GetResponse() model.PlcReadResponse {
+ ret := _m.Called()
+
+ var r0 model.PlcReadResponse
+ if rf, ok := ret.Get(0).(func() model.PlcReadResponse); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcReadResponse)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequestResult_GetResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponse'
+type MockPlcReadRequestResult_GetResponse_Call struct {
+ *mock.Call
+}
+
+// GetResponse is a helper method to define mock.On call
+func (_e *MockPlcReadRequestResult_Expecter) GetResponse() *MockPlcReadRequestResult_GetResponse_Call {
+ return &MockPlcReadRequestResult_GetResponse_Call{Call: _e.mock.On("GetResponse")}
+}
+
+func (_c *MockPlcReadRequestResult_GetResponse_Call) Run(run func()) *MockPlcReadRequestResult_GetResponse_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetResponse_Call) Return(_a0 model.PlcReadResponse) *MockPlcReadRequestResult_GetResponse_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequestResult_GetResponse_Call) RunAndReturn(run func() model.PlcReadResponse) *MockPlcReadRequestResult_GetResponse_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcReadRequestResult interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcReadRequestResult creates a new instance of MockPlcReadRequestResult. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcReadRequestResult(t mockConstructorTestingTNewMockPlcReadRequestResult) *MockPlcReadRequestResult {
+ mock := &MockPlcReadRequestResult{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_PlcReadRequest_test.go b/plc4go/spi/interceptors/mock_PlcReadRequest_test.go
new file mode 100644
index 0000000000..b868ea656d
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcReadRequest_test.go
@@ -0,0 +1,401 @@
+/*
+ * 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 interceptors
+
+import (
+ context "context"
+
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+
+ spi "github.com/apache/plc4x/plc4go/spi"
+)
+
+// MockPlcReadRequest is an autogenerated mock type for the PlcReadRequest type
+type MockPlcReadRequest struct {
+ mock.Mock
+}
+
+type MockPlcReadRequest_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcReadRequest) EXPECT() *MockPlcReadRequest_Expecter {
+ return &MockPlcReadRequest_Expecter{mock: &_m.Mock}
+}
+
+// Execute provides a mock function with given fields:
+func (_m *MockPlcReadRequest) Execute() <-chan model.PlcReadRequestResult {
+ ret := _m.Called()
+
+ var r0 <-chan model.PlcReadRequestResult
+ if rf, ok := ret.Get(0).(func() <-chan model.PlcReadRequestResult); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan model.PlcReadRequestResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
+type MockPlcReadRequest_Execute_Call struct {
+ *mock.Call
+}
+
+// Execute is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) Execute() *MockPlcReadRequest_Execute_Call {
+ return &MockPlcReadRequest_Execute_Call{Call: _e.mock.On("Execute")}
+}
+
+func (_c *MockPlcReadRequest_Execute_Call) Run(run func()) *MockPlcReadRequest_Execute_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_Execute_Call) Return(_a0 <-chan model.PlcReadRequestResult) *MockPlcReadRequest_Execute_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_Execute_Call) RunAndReturn(run func() <-chan model.PlcReadRequestResult) *MockPlcReadRequest_Execute_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ExecuteWithContext provides a mock function with given fields: ctx
+func (_m *MockPlcReadRequest) ExecuteWithContext(ctx context.Context) <-chan model.PlcReadRequestResult {
+ ret := _m.Called(ctx)
+
+ var r0 <-chan model.PlcReadRequestResult
+ if rf, ok := ret.Get(0).(func(context.Context) <-chan model.PlcReadRequestResult); ok {
+ r0 = rf(ctx)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan model.PlcReadRequestResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_ExecuteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteWithContext'
+type MockPlcReadRequest_ExecuteWithContext_Call struct {
+ *mock.Call
+}
+
+// ExecuteWithContext is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockPlcReadRequest_Expecter) ExecuteWithContext(ctx interface{}) *MockPlcReadRequest_ExecuteWithContext_Call {
+ return &MockPlcReadRequest_ExecuteWithContext_Call{Call: _e.mock.On("ExecuteWithContext", ctx)}
+}
+
+func (_c *MockPlcReadRequest_ExecuteWithContext_Call) Run(run func(ctx context.Context)) *MockPlcReadRequest_ExecuteWithContext_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_ExecuteWithContext_Call) Return(_a0 <-chan model.PlcReadRequestResult) *MockPlcReadRequest_ExecuteWithContext_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_ExecuteWithContext_Call) RunAndReturn(run func(context.Context) <-chan model.PlcReadRequestResult) *MockPlcReadRequest_ExecuteWithContext_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetReadRequestInterceptor provides a mock function with given fields:
+func (_m *MockPlcReadRequest) GetReadRequestInterceptor() ReadRequestInterceptor {
+ ret := _m.Called()
+
+ var r0 ReadRequestInterceptor
+ if rf, ok := ret.Get(0).(func() ReadRequestInterceptor); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(ReadRequestInterceptor)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_GetReadRequestInterceptor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReadRequestInterceptor'
+type MockPlcReadRequest_GetReadRequestInterceptor_Call struct {
+ *mock.Call
+}
+
+// GetReadRequestInterceptor is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) GetReadRequestInterceptor() *MockPlcReadRequest_GetReadRequestInterceptor_Call {
+ return &MockPlcReadRequest_GetReadRequestInterceptor_Call{Call: _e.mock.On("GetReadRequestInterceptor")}
+}
+
+func (_c *MockPlcReadRequest_GetReadRequestInterceptor_Call) Run(run func()) *MockPlcReadRequest_GetReadRequestInterceptor_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetReadRequestInterceptor_Call) Return(_a0 ReadRequestInterceptor) *MockPlcReadRequest_GetReadRequestInterceptor_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetReadRequestInterceptor_Call) RunAndReturn(run func() ReadRequestInterceptor) *MockPlcReadRequest_GetReadRequestInterceptor_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetReader provides a mock function with given fields:
+func (_m *MockPlcReadRequest) GetReader() spi.PlcReader {
+ ret := _m.Called()
+
+ var r0 spi.PlcReader
+ if rf, ok := ret.Get(0).(func() spi.PlcReader); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(spi.PlcReader)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_GetReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReader'
+type MockPlcReadRequest_GetReader_Call struct {
+ *mock.Call
+}
+
+// GetReader is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) GetReader() *MockPlcReadRequest_GetReader_Call {
+ return &MockPlcReadRequest_GetReader_Call{Call: _e.mock.On("GetReader")}
+}
+
+func (_c *MockPlcReadRequest_GetReader_Call) Run(run func()) *MockPlcReadRequest_GetReader_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetReader_Call) Return(_a0 spi.PlcReader) *MockPlcReadRequest_GetReader_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetReader_Call) RunAndReturn(run func() spi.PlcReader) *MockPlcReadRequest_GetReader_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTag provides a mock function with given fields: tagName
+func (_m *MockPlcReadRequest) GetTag(tagName string) model.PlcTag {
+ ret := _m.Called(tagName)
+
+ var r0 model.PlcTag
+ if rf, ok := ret.Get(0).(func(string) model.PlcTag); ok {
+ r0 = rf(tagName)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcTag)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_GetTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTag'
+type MockPlcReadRequest_GetTag_Call struct {
+ *mock.Call
+}
+
+// GetTag is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcReadRequest_Expecter) GetTag(tagName interface{}) *MockPlcReadRequest_GetTag_Call {
+ return &MockPlcReadRequest_GetTag_Call{Call: _e.mock.On("GetTag", tagName)}
+}
+
+func (_c *MockPlcReadRequest_GetTag_Call) Run(run func(tagName string)) *MockPlcReadRequest_GetTag_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetTag_Call) Return(_a0 model.PlcTag) *MockPlcReadRequest_GetTag_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetTag_Call) RunAndReturn(run func(string) model.PlcTag) *MockPlcReadRequest_GetTag_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTagNames provides a mock function with given fields:
+func (_m *MockPlcReadRequest) GetTagNames() []string {
+ ret := _m.Called()
+
+ var r0 []string
+ if rf, ok := ret.Get(0).(func() []string); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]string)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadRequest_GetTagNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTagNames'
+type MockPlcReadRequest_GetTagNames_Call struct {
+ *mock.Call
+}
+
+// GetTagNames is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) GetTagNames() *MockPlcReadRequest_GetTagNames_Call {
+ return &MockPlcReadRequest_GetTagNames_Call{Call: _e.mock.On("GetTagNames")}
+}
+
+func (_c *MockPlcReadRequest_GetTagNames_Call) Run(run func()) *MockPlcReadRequest_GetTagNames_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetTagNames_Call) Return(_a0 []string) *MockPlcReadRequest_GetTagNames_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_GetTagNames_Call) RunAndReturn(run func() []string) *MockPlcReadRequest_GetTagNames_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsAPlcMessage provides a mock function with given fields:
+func (_m *MockPlcReadRequest) IsAPlcMessage() 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
+}
+
+// MockPlcReadRequest_IsAPlcMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAPlcMessage'
+type MockPlcReadRequest_IsAPlcMessage_Call struct {
+ *mock.Call
+}
+
+// IsAPlcMessage is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) IsAPlcMessage() *MockPlcReadRequest_IsAPlcMessage_Call {
+ return &MockPlcReadRequest_IsAPlcMessage_Call{Call: _e.mock.On("IsAPlcMessage")}
+}
+
+func (_c *MockPlcReadRequest_IsAPlcMessage_Call) Run(run func()) *MockPlcReadRequest_IsAPlcMessage_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_IsAPlcMessage_Call) Return(_a0 bool) *MockPlcReadRequest_IsAPlcMessage_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_IsAPlcMessage_Call) RunAndReturn(run func() bool) *MockPlcReadRequest_IsAPlcMessage_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// String provides a mock function with given fields:
+func (_m *MockPlcReadRequest) 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
+}
+
+// MockPlcReadRequest_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type MockPlcReadRequest_String_Call struct {
+ *mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *MockPlcReadRequest_Expecter) String() *MockPlcReadRequest_String_Call {
+ return &MockPlcReadRequest_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *MockPlcReadRequest_String_Call) Run(run func()) *MockPlcReadRequest_String_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadRequest_String_Call) Return(_a0 string) *MockPlcReadRequest_String_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadRequest_String_Call) RunAndReturn(run func() string) *MockPlcReadRequest_String_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcReadRequest interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcReadRequest creates a new instance of MockPlcReadRequest. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcReadRequest(t mockConstructorTestingTNewMockPlcReadRequest) *MockPlcReadRequest {
+ mock := &MockPlcReadRequest{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_PlcReadResponse_test.go b/plc4go/spi/interceptors/mock_PlcReadResponse_test.go
new file mode 100644
index 0000000000..34b8fe67aa
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcReadResponse_test.go
@@ -0,0 +1,311 @@
+/*
+ * 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 interceptors
+
+import (
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+
+ values "github.com/apache/plc4x/plc4go/pkg/api/values"
+)
+
+// MockPlcReadResponse is an autogenerated mock type for the PlcReadResponse type
+type MockPlcReadResponse struct {
+ mock.Mock
+}
+
+type MockPlcReadResponse_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcReadResponse) EXPECT() *MockPlcReadResponse_Expecter {
+ return &MockPlcReadResponse_Expecter{mock: &_m.Mock}
+}
+
+// GetRequest provides a mock function with given fields:
+func (_m *MockPlcReadResponse) GetRequest() model.PlcReadRequest {
+ ret := _m.Called()
+
+ var r0 model.PlcReadRequest
+ if rf, ok := ret.Get(0).(func() model.PlcReadRequest); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcReadRequest)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadResponse_GetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRequest'
+type MockPlcReadResponse_GetRequest_Call struct {
+ *mock.Call
+}
+
+// GetRequest is a helper method to define mock.On call
+func (_e *MockPlcReadResponse_Expecter) GetRequest() *MockPlcReadResponse_GetRequest_Call {
+ return &MockPlcReadResponse_GetRequest_Call{Call: _e.mock.On("GetRequest")}
+}
+
+func (_c *MockPlcReadResponse_GetRequest_Call) Run(run func()) *MockPlcReadResponse_GetRequest_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetRequest_Call) Return(_a0 model.PlcReadRequest) *MockPlcReadResponse_GetRequest_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetRequest_Call) RunAndReturn(run func() model.PlcReadRequest) *MockPlcReadResponse_GetRequest_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetResponseCode provides a mock function with given fields: tagName
+func (_m *MockPlcReadResponse) GetResponseCode(tagName string) model.PlcResponseCode {
+ ret := _m.Called(tagName)
+
+ var r0 model.PlcResponseCode
+ if rf, ok := ret.Get(0).(func(string) model.PlcResponseCode); ok {
+ r0 = rf(tagName)
+ } else {
+ r0 = ret.Get(0).(model.PlcResponseCode)
+ }
+
+ return r0
+}
+
+// MockPlcReadResponse_GetResponseCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseCode'
+type MockPlcReadResponse_GetResponseCode_Call struct {
+ *mock.Call
+}
+
+// GetResponseCode is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcReadResponse_Expecter) GetResponseCode(tagName interface{}) *MockPlcReadResponse_GetResponseCode_Call {
+ return &MockPlcReadResponse_GetResponseCode_Call{Call: _e.mock.On("GetResponseCode", tagName)}
+}
+
+func (_c *MockPlcReadResponse_GetResponseCode_Call) Run(run func(tagName string)) *MockPlcReadResponse_GetResponseCode_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetResponseCode_Call) Return(_a0 model.PlcResponseCode) *MockPlcReadResponse_GetResponseCode_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetResponseCode_Call) RunAndReturn(run func(string) model.PlcResponseCode) *MockPlcReadResponse_GetResponseCode_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTagNames provides a mock function with given fields:
+func (_m *MockPlcReadResponse) GetTagNames() []string {
+ ret := _m.Called()
+
+ var r0 []string
+ if rf, ok := ret.Get(0).(func() []string); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]string)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadResponse_GetTagNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTagNames'
+type MockPlcReadResponse_GetTagNames_Call struct {
+ *mock.Call
+}
+
+// GetTagNames is a helper method to define mock.On call
+func (_e *MockPlcReadResponse_Expecter) GetTagNames() *MockPlcReadResponse_GetTagNames_Call {
+ return &MockPlcReadResponse_GetTagNames_Call{Call: _e.mock.On("GetTagNames")}
+}
+
+func (_c *MockPlcReadResponse_GetTagNames_Call) Run(run func()) *MockPlcReadResponse_GetTagNames_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetTagNames_Call) Return(_a0 []string) *MockPlcReadResponse_GetTagNames_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetTagNames_Call) RunAndReturn(run func() []string) *MockPlcReadResponse_GetTagNames_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetValue provides a mock function with given fields: tagName
+func (_m *MockPlcReadResponse) GetValue(tagName string) values.PlcValue {
+ ret := _m.Called(tagName)
+
+ var r0 values.PlcValue
+ if rf, ok := ret.Get(0).(func(string) values.PlcValue); ok {
+ r0 = rf(tagName)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(values.PlcValue)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcReadResponse_GetValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValue'
+type MockPlcReadResponse_GetValue_Call struct {
+ *mock.Call
+}
+
+// GetValue is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcReadResponse_Expecter) GetValue(tagName interface{}) *MockPlcReadResponse_GetValue_Call {
+ return &MockPlcReadResponse_GetValue_Call{Call: _e.mock.On("GetValue", tagName)}
+}
+
+func (_c *MockPlcReadResponse_GetValue_Call) Run(run func(tagName string)) *MockPlcReadResponse_GetValue_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetValue_Call) Return(_a0 values.PlcValue) *MockPlcReadResponse_GetValue_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_GetValue_Call) RunAndReturn(run func(string) values.PlcValue) *MockPlcReadResponse_GetValue_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsAPlcMessage provides a mock function with given fields:
+func (_m *MockPlcReadResponse) IsAPlcMessage() 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
+}
+
+// MockPlcReadResponse_IsAPlcMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAPlcMessage'
+type MockPlcReadResponse_IsAPlcMessage_Call struct {
+ *mock.Call
+}
+
+// IsAPlcMessage is a helper method to define mock.On call
+func (_e *MockPlcReadResponse_Expecter) IsAPlcMessage() *MockPlcReadResponse_IsAPlcMessage_Call {
+ return &MockPlcReadResponse_IsAPlcMessage_Call{Call: _e.mock.On("IsAPlcMessage")}
+}
+
+func (_c *MockPlcReadResponse_IsAPlcMessage_Call) Run(run func()) *MockPlcReadResponse_IsAPlcMessage_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_IsAPlcMessage_Call) Return(_a0 bool) *MockPlcReadResponse_IsAPlcMessage_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_IsAPlcMessage_Call) RunAndReturn(run func() bool) *MockPlcReadResponse_IsAPlcMessage_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// String provides a mock function with given fields:
+func (_m *MockPlcReadResponse) 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
+}
+
+// MockPlcReadResponse_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type MockPlcReadResponse_String_Call struct {
+ *mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *MockPlcReadResponse_Expecter) String() *MockPlcReadResponse_String_Call {
+ return &MockPlcReadResponse_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *MockPlcReadResponse_String_Call) Run(run func()) *MockPlcReadResponse_String_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcReadResponse_String_Call) Return(_a0 string) *MockPlcReadResponse_String_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcReadResponse_String_Call) RunAndReturn(run func() string) *MockPlcReadResponse_String_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcReadResponse interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcReadResponse creates a new instance of MockPlcReadResponse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcReadResponse(t mockConstructorTestingTNewMockPlcReadResponse) *MockPlcReadResponse {
+ mock := &MockPlcReadResponse{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_PlcWriteRequestResult_test.go b/plc4go/spi/interceptors/mock_PlcWriteRequestResult_test.go
new file mode 100644
index 0000000000..6d38b9754f
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcWriteRequestResult_test.go
@@ -0,0 +1,182 @@
+/*
+ * 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 interceptors
+
+import (
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockPlcWriteRequestResult is an autogenerated mock type for the PlcWriteRequestResult type
+type MockPlcWriteRequestResult struct {
+ mock.Mock
+}
+
+type MockPlcWriteRequestResult_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcWriteRequestResult) EXPECT() *MockPlcWriteRequestResult_Expecter {
+ return &MockPlcWriteRequestResult_Expecter{mock: &_m.Mock}
+}
+
+// GetErr provides a mock function with given fields:
+func (_m *MockPlcWriteRequestResult) 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
+}
+
+// MockPlcWriteRequestResult_GetErr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetErr'
+type MockPlcWriteRequestResult_GetErr_Call struct {
+ *mock.Call
+}
+
+// GetErr is a helper method to define mock.On call
+func (_e *MockPlcWriteRequestResult_Expecter) GetErr() *MockPlcWriteRequestResult_GetErr_Call {
+ return &MockPlcWriteRequestResult_GetErr_Call{Call: _e.mock.On("GetErr")}
+}
+
+func (_c *MockPlcWriteRequestResult_GetErr_Call) Run(run func()) *MockPlcWriteRequestResult_GetErr_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetErr_Call) Return(_a0 error) *MockPlcWriteRequestResult_GetErr_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetErr_Call) RunAndReturn(run func() error) *MockPlcWriteRequestResult_GetErr_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetRequest provides a mock function with given fields:
+func (_m *MockPlcWriteRequestResult) GetRequest() model.PlcWriteRequest {
+ ret := _m.Called()
+
+ var r0 model.PlcWriteRequest
+ if rf, ok := ret.Get(0).(func() model.PlcWriteRequest); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcWriteRequest)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequestResult_GetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRequest'
+type MockPlcWriteRequestResult_GetRequest_Call struct {
+ *mock.Call
+}
+
+// GetRequest is a helper method to define mock.On call
+func (_e *MockPlcWriteRequestResult_Expecter) GetRequest() *MockPlcWriteRequestResult_GetRequest_Call {
+ return &MockPlcWriteRequestResult_GetRequest_Call{Call: _e.mock.On("GetRequest")}
+}
+
+func (_c *MockPlcWriteRequestResult_GetRequest_Call) Run(run func()) *MockPlcWriteRequestResult_GetRequest_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetRequest_Call) Return(_a0 model.PlcWriteRequest) *MockPlcWriteRequestResult_GetRequest_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetRequest_Call) RunAndReturn(run func() model.PlcWriteRequest) *MockPlcWriteRequestResult_GetRequest_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetResponse provides a mock function with given fields:
+func (_m *MockPlcWriteRequestResult) GetResponse() model.PlcWriteResponse {
+ ret := _m.Called()
+
+ var r0 model.PlcWriteResponse
+ if rf, ok := ret.Get(0).(func() model.PlcWriteResponse); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcWriteResponse)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequestResult_GetResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponse'
+type MockPlcWriteRequestResult_GetResponse_Call struct {
+ *mock.Call
+}
+
+// GetResponse is a helper method to define mock.On call
+func (_e *MockPlcWriteRequestResult_Expecter) GetResponse() *MockPlcWriteRequestResult_GetResponse_Call {
+ return &MockPlcWriteRequestResult_GetResponse_Call{Call: _e.mock.On("GetResponse")}
+}
+
+func (_c *MockPlcWriteRequestResult_GetResponse_Call) Run(run func()) *MockPlcWriteRequestResult_GetResponse_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetResponse_Call) Return(_a0 model.PlcWriteResponse) *MockPlcWriteRequestResult_GetResponse_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequestResult_GetResponse_Call) RunAndReturn(run func() model.PlcWriteResponse) *MockPlcWriteRequestResult_GetResponse_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcWriteRequestResult interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcWriteRequestResult creates a new instance of MockPlcWriteRequestResult. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcWriteRequestResult(t mockConstructorTestingTNewMockPlcWriteRequestResult) *MockPlcWriteRequestResult {
+ mock := &MockPlcWriteRequestResult{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_PlcWriteRequest_test.go b/plc4go/spi/interceptors/mock_PlcWriteRequest_test.go
new file mode 100644
index 0000000000..a8f9467b34
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcWriteRequest_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 interceptors
+
+import (
+ context "context"
+
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+
+ spi "github.com/apache/plc4x/plc4go/spi"
+
+ values "github.com/apache/plc4x/plc4go/pkg/api/values"
+)
+
+// MockPlcWriteRequest is an autogenerated mock type for the PlcWriteRequest type
+type MockPlcWriteRequest struct {
+ mock.Mock
+}
+
+type MockPlcWriteRequest_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcWriteRequest) EXPECT() *MockPlcWriteRequest_Expecter {
+ return &MockPlcWriteRequest_Expecter{mock: &_m.Mock}
+}
+
+// Execute provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) Execute() <-chan model.PlcWriteRequestResult {
+ ret := _m.Called()
+
+ var r0 <-chan model.PlcWriteRequestResult
+ if rf, ok := ret.Get(0).(func() <-chan model.PlcWriteRequestResult); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan model.PlcWriteRequestResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
+type MockPlcWriteRequest_Execute_Call struct {
+ *mock.Call
+}
+
+// Execute is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) Execute() *MockPlcWriteRequest_Execute_Call {
+ return &MockPlcWriteRequest_Execute_Call{Call: _e.mock.On("Execute")}
+}
+
+func (_c *MockPlcWriteRequest_Execute_Call) Run(run func()) *MockPlcWriteRequest_Execute_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_Execute_Call) Return(_a0 <-chan model.PlcWriteRequestResult) *MockPlcWriteRequest_Execute_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_Execute_Call) RunAndReturn(run func() <-chan model.PlcWriteRequestResult) *MockPlcWriteRequest_Execute_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// ExecuteWithContext provides a mock function with given fields: ctx
+func (_m *MockPlcWriteRequest) ExecuteWithContext(ctx context.Context) <-chan model.PlcWriteRequestResult {
+ ret := _m.Called(ctx)
+
+ var r0 <-chan model.PlcWriteRequestResult
+ if rf, ok := ret.Get(0).(func(context.Context) <-chan model.PlcWriteRequestResult); ok {
+ r0 = rf(ctx)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(<-chan model.PlcWriteRequestResult)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_ExecuteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteWithContext'
+type MockPlcWriteRequest_ExecuteWithContext_Call struct {
+ *mock.Call
+}
+
+// ExecuteWithContext is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockPlcWriteRequest_Expecter) ExecuteWithContext(ctx interface{}) *MockPlcWriteRequest_ExecuteWithContext_Call {
+ return &MockPlcWriteRequest_ExecuteWithContext_Call{Call: _e.mock.On("ExecuteWithContext", ctx)}
+}
+
+func (_c *MockPlcWriteRequest_ExecuteWithContext_Call) Run(run func(ctx context.Context)) *MockPlcWriteRequest_ExecuteWithContext_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_ExecuteWithContext_Call) Return(_a0 <-chan model.PlcWriteRequestResult) *MockPlcWriteRequest_ExecuteWithContext_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_ExecuteWithContext_Call) RunAndReturn(run func(context.Context) <-chan model.PlcWriteRequestResult) *MockPlcWriteRequest_ExecuteWithContext_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTag provides a mock function with given fields: tagName
+func (_m *MockPlcWriteRequest) GetTag(tagName string) model.PlcTag {
+ ret := _m.Called(tagName)
+
+ var r0 model.PlcTag
+ if rf, ok := ret.Get(0).(func(string) model.PlcTag); ok {
+ r0 = rf(tagName)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcTag)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_GetTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTag'
+type MockPlcWriteRequest_GetTag_Call struct {
+ *mock.Call
+}
+
+// GetTag is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcWriteRequest_Expecter) GetTag(tagName interface{}) *MockPlcWriteRequest_GetTag_Call {
+ return &MockPlcWriteRequest_GetTag_Call{Call: _e.mock.On("GetTag", tagName)}
+}
+
+func (_c *MockPlcWriteRequest_GetTag_Call) Run(run func(tagName string)) *MockPlcWriteRequest_GetTag_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetTag_Call) Return(_a0 model.PlcTag) *MockPlcWriteRequest_GetTag_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetTag_Call) RunAndReturn(run func(string) model.PlcTag) *MockPlcWriteRequest_GetTag_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTagNames provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) GetTagNames() []string {
+ ret := _m.Called()
+
+ var r0 []string
+ if rf, ok := ret.Get(0).(func() []string); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]string)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_GetTagNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTagNames'
+type MockPlcWriteRequest_GetTagNames_Call struct {
+ *mock.Call
+}
+
+// GetTagNames is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) GetTagNames() *MockPlcWriteRequest_GetTagNames_Call {
+ return &MockPlcWriteRequest_GetTagNames_Call{Call: _e.mock.On("GetTagNames")}
+}
+
+func (_c *MockPlcWriteRequest_GetTagNames_Call) Run(run func()) *MockPlcWriteRequest_GetTagNames_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetTagNames_Call) Return(_a0 []string) *MockPlcWriteRequest_GetTagNames_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetTagNames_Call) RunAndReturn(run func() []string) *MockPlcWriteRequest_GetTagNames_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetValue provides a mock function with given fields: tagName
+func (_m *MockPlcWriteRequest) GetValue(tagName string) values.PlcValue {
+ ret := _m.Called(tagName)
+
+ var r0 values.PlcValue
+ if rf, ok := ret.Get(0).(func(string) values.PlcValue); ok {
+ r0 = rf(tagName)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(values.PlcValue)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_GetValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValue'
+type MockPlcWriteRequest_GetValue_Call struct {
+ *mock.Call
+}
+
+// GetValue is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcWriteRequest_Expecter) GetValue(tagName interface{}) *MockPlcWriteRequest_GetValue_Call {
+ return &MockPlcWriteRequest_GetValue_Call{Call: _e.mock.On("GetValue", tagName)}
+}
+
+func (_c *MockPlcWriteRequest_GetValue_Call) Run(run func(tagName string)) *MockPlcWriteRequest_GetValue_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetValue_Call) Return(_a0 values.PlcValue) *MockPlcWriteRequest_GetValue_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetValue_Call) RunAndReturn(run func(string) values.PlcValue) *MockPlcWriteRequest_GetValue_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetWriteRequestInterceptor provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) GetWriteRequestInterceptor() WriteRequestInterceptor {
+ ret := _m.Called()
+
+ var r0 WriteRequestInterceptor
+ if rf, ok := ret.Get(0).(func() WriteRequestInterceptor); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(WriteRequestInterceptor)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_GetWriteRequestInterceptor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWriteRequestInterceptor'
+type MockPlcWriteRequest_GetWriteRequestInterceptor_Call struct {
+ *mock.Call
+}
+
+// GetWriteRequestInterceptor is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) GetWriteRequestInterceptor() *MockPlcWriteRequest_GetWriteRequestInterceptor_Call {
+ return &MockPlcWriteRequest_GetWriteRequestInterceptor_Call{Call: _e.mock.On("GetWriteRequestInterceptor")}
+}
+
+func (_c *MockPlcWriteRequest_GetWriteRequestInterceptor_Call) Run(run func()) *MockPlcWriteRequest_GetWriteRequestInterceptor_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetWriteRequestInterceptor_Call) Return(_a0 WriteRequestInterceptor) *MockPlcWriteRequest_GetWriteRequestInterceptor_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetWriteRequestInterceptor_Call) RunAndReturn(run func() WriteRequestInterceptor) *MockPlcWriteRequest_GetWriteRequestInterceptor_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetWriter provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) GetWriter() spi.PlcWriter {
+ ret := _m.Called()
+
+ var r0 spi.PlcWriter
+ if rf, ok := ret.Get(0).(func() spi.PlcWriter); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(spi.PlcWriter)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteRequest_GetWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWriter'
+type MockPlcWriteRequest_GetWriter_Call struct {
+ *mock.Call
+}
+
+// GetWriter is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) GetWriter() *MockPlcWriteRequest_GetWriter_Call {
+ return &MockPlcWriteRequest_GetWriter_Call{Call: _e.mock.On("GetWriter")}
+}
+
+func (_c *MockPlcWriteRequest_GetWriter_Call) Run(run func()) *MockPlcWriteRequest_GetWriter_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetWriter_Call) Return(_a0 spi.PlcWriter) *MockPlcWriteRequest_GetWriter_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_GetWriter_Call) RunAndReturn(run func() spi.PlcWriter) *MockPlcWriteRequest_GetWriter_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsAPlcMessage provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) IsAPlcMessage() 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
+}
+
+// MockPlcWriteRequest_IsAPlcMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAPlcMessage'
+type MockPlcWriteRequest_IsAPlcMessage_Call struct {
+ *mock.Call
+}
+
+// IsAPlcMessage is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) IsAPlcMessage() *MockPlcWriteRequest_IsAPlcMessage_Call {
+ return &MockPlcWriteRequest_IsAPlcMessage_Call{Call: _e.mock.On("IsAPlcMessage")}
+}
+
+func (_c *MockPlcWriteRequest_IsAPlcMessage_Call) Run(run func()) *MockPlcWriteRequest_IsAPlcMessage_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_IsAPlcMessage_Call) Return(_a0 bool) *MockPlcWriteRequest_IsAPlcMessage_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_IsAPlcMessage_Call) RunAndReturn(run func() bool) *MockPlcWriteRequest_IsAPlcMessage_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// String provides a mock function with given fields:
+func (_m *MockPlcWriteRequest) 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
+}
+
+// MockPlcWriteRequest_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type MockPlcWriteRequest_String_Call struct {
+ *mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *MockPlcWriteRequest_Expecter) String() *MockPlcWriteRequest_String_Call {
+ return &MockPlcWriteRequest_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *MockPlcWriteRequest_String_Call) Run(run func()) *MockPlcWriteRequest_String_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_String_Call) Return(_a0 string) *MockPlcWriteRequest_String_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteRequest_String_Call) RunAndReturn(run func() string) *MockPlcWriteRequest_String_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcWriteRequest interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcWriteRequest creates a new instance of MockPlcWriteRequest. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcWriteRequest(t mockConstructorTestingTNewMockPlcWriteRequest) *MockPlcWriteRequest {
+ mock := &MockPlcWriteRequest{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_PlcWriteResponse_test.go b/plc4go/spi/interceptors/mock_PlcWriteResponse_test.go
new file mode 100644
index 0000000000..9b71daf971
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_PlcWriteResponse_test.go
@@ -0,0 +1,265 @@
+/*
+ * 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 interceptors
+
+import (
+ model "github.com/apache/plc4x/plc4go/pkg/api/model"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockPlcWriteResponse is an autogenerated mock type for the PlcWriteResponse type
+type MockPlcWriteResponse struct {
+ mock.Mock
+}
+
+type MockPlcWriteResponse_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockPlcWriteResponse) EXPECT() *MockPlcWriteResponse_Expecter {
+ return &MockPlcWriteResponse_Expecter{mock: &_m.Mock}
+}
+
+// GetRequest provides a mock function with given fields:
+func (_m *MockPlcWriteResponse) GetRequest() model.PlcWriteRequest {
+ ret := _m.Called()
+
+ var r0 model.PlcWriteRequest
+ if rf, ok := ret.Get(0).(func() model.PlcWriteRequest); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).(model.PlcWriteRequest)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteResponse_GetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRequest'
+type MockPlcWriteResponse_GetRequest_Call struct {
+ *mock.Call
+}
+
+// GetRequest is a helper method to define mock.On call
+func (_e *MockPlcWriteResponse_Expecter) GetRequest() *MockPlcWriteResponse_GetRequest_Call {
+ return &MockPlcWriteResponse_GetRequest_Call{Call: _e.mock.On("GetRequest")}
+}
+
+func (_c *MockPlcWriteResponse_GetRequest_Call) Run(run func()) *MockPlcWriteResponse_GetRequest_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetRequest_Call) Return(_a0 model.PlcWriteRequest) *MockPlcWriteResponse_GetRequest_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetRequest_Call) RunAndReturn(run func() model.PlcWriteRequest) *MockPlcWriteResponse_GetRequest_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetResponseCode provides a mock function with given fields: tagName
+func (_m *MockPlcWriteResponse) GetResponseCode(tagName string) model.PlcResponseCode {
+ ret := _m.Called(tagName)
+
+ var r0 model.PlcResponseCode
+ if rf, ok := ret.Get(0).(func(string) model.PlcResponseCode); ok {
+ r0 = rf(tagName)
+ } else {
+ r0 = ret.Get(0).(model.PlcResponseCode)
+ }
+
+ return r0
+}
+
+// MockPlcWriteResponse_GetResponseCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseCode'
+type MockPlcWriteResponse_GetResponseCode_Call struct {
+ *mock.Call
+}
+
+// GetResponseCode is a helper method to define mock.On call
+// - tagName string
+func (_e *MockPlcWriteResponse_Expecter) GetResponseCode(tagName interface{}) *MockPlcWriteResponse_GetResponseCode_Call {
+ return &MockPlcWriteResponse_GetResponseCode_Call{Call: _e.mock.On("GetResponseCode", tagName)}
+}
+
+func (_c *MockPlcWriteResponse_GetResponseCode_Call) Run(run func(tagName string)) *MockPlcWriteResponse_GetResponseCode_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(string))
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetResponseCode_Call) Return(_a0 model.PlcResponseCode) *MockPlcWriteResponse_GetResponseCode_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetResponseCode_Call) RunAndReturn(run func(string) model.PlcResponseCode) *MockPlcWriteResponse_GetResponseCode_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetTagNames provides a mock function with given fields:
+func (_m *MockPlcWriteResponse) GetTagNames() []string {
+ ret := _m.Called()
+
+ var r0 []string
+ if rf, ok := ret.Get(0).(func() []string); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]string)
+ }
+ }
+
+ return r0
+}
+
+// MockPlcWriteResponse_GetTagNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTagNames'
+type MockPlcWriteResponse_GetTagNames_Call struct {
+ *mock.Call
+}
+
+// GetTagNames is a helper method to define mock.On call
+func (_e *MockPlcWriteResponse_Expecter) GetTagNames() *MockPlcWriteResponse_GetTagNames_Call {
+ return &MockPlcWriteResponse_GetTagNames_Call{Call: _e.mock.On("GetTagNames")}
+}
+
+func (_c *MockPlcWriteResponse_GetTagNames_Call) Run(run func()) *MockPlcWriteResponse_GetTagNames_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetTagNames_Call) Return(_a0 []string) *MockPlcWriteResponse_GetTagNames_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_GetTagNames_Call) RunAndReturn(run func() []string) *MockPlcWriteResponse_GetTagNames_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// IsAPlcMessage provides a mock function with given fields:
+func (_m *MockPlcWriteResponse) IsAPlcMessage() 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
+}
+
+// MockPlcWriteResponse_IsAPlcMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAPlcMessage'
+type MockPlcWriteResponse_IsAPlcMessage_Call struct {
+ *mock.Call
+}
+
+// IsAPlcMessage is a helper method to define mock.On call
+func (_e *MockPlcWriteResponse_Expecter) IsAPlcMessage() *MockPlcWriteResponse_IsAPlcMessage_Call {
+ return &MockPlcWriteResponse_IsAPlcMessage_Call{Call: _e.mock.On("IsAPlcMessage")}
+}
+
+func (_c *MockPlcWriteResponse_IsAPlcMessage_Call) Run(run func()) *MockPlcWriteResponse_IsAPlcMessage_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_IsAPlcMessage_Call) Return(_a0 bool) *MockPlcWriteResponse_IsAPlcMessage_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_IsAPlcMessage_Call) RunAndReturn(run func() bool) *MockPlcWriteResponse_IsAPlcMessage_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// String provides a mock function with given fields:
+func (_m *MockPlcWriteResponse) 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
+}
+
+// MockPlcWriteResponse_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
+type MockPlcWriteResponse_String_Call struct {
+ *mock.Call
+}
+
+// String is a helper method to define mock.On call
+func (_e *MockPlcWriteResponse_Expecter) String() *MockPlcWriteResponse_String_Call {
+ return &MockPlcWriteResponse_String_Call{Call: _e.mock.On("String")}
+}
+
+func (_c *MockPlcWriteResponse_String_Call) Run(run func()) *MockPlcWriteResponse_String_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_String_Call) Return(_a0 string) *MockPlcWriteResponse_String_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockPlcWriteResponse_String_Call) RunAndReturn(run func() string) *MockPlcWriteResponse_String_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockPlcWriteResponse interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockPlcWriteResponse creates a new instance of MockPlcWriteResponse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockPlcWriteResponse(t mockConstructorTestingTNewMockPlcWriteResponse) *MockPlcWriteResponse {
+ mock := &MockPlcWriteResponse{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/interceptors/mock_requirements.go b/plc4go/spi/interceptors/mock_requirements.go
new file mode 100644
index 0000000000..976a835198
--- /dev/null
+++ b/plc4go/spi/interceptors/mock_requirements.go
@@ -0,0 +1,60 @@
+/*
+ * 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 interceptors
+
+import (
+ apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
+)
+
+// Note this file is a Helper for mockery to generate use mocks from other package
+
+// Deprecated: don't use it in productive code
+type PlcReadRequest interface {
+ apiModel.PlcReadRequest
+ ReaderExposer
+ ReadRequestInterceptorExposer
+}
+
+// Deprecated: don't use it in productive code
+type PlcReadRequestResult interface {
+ apiModel.PlcReadRequestResult
+}
+
+// Deprecated: don't use it in productive code
+type PlcReadResponse interface {
+ apiModel.PlcReadResponse
+}
+
+// Deprecated: don't use it in productive code
+type PlcWriteRequest interface {
+ apiModel.PlcWriteRequest
+ WriterExposer
+ WriteRequestInterceptorExposer
+}
+
+// Deprecated: don't use it in productive code
+type PlcWriteRequestResult interface {
+ apiModel.PlcWriteRequestResult
+}
+
+// Deprecated: don't use it in productive code
+type PlcWriteResponse interface {
+ apiModel.PlcWriteResponse
+}
diff --git a/plc4go/spi/mock_CompletionFuture_test.go b/plc4go/spi/mock_CompletionFuture_test.go
new file mode 100644
index 0000000000..881685a7ce
--- /dev/null
+++ b/plc4go/spi/mock_CompletionFuture_test.go
@@ -0,0 +1,132 @@
+/*
+ * 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 spi
+
+import (
+ context "context"
+
+ mock "github.com/stretchr/testify/mock"
+)
+
+// MockCompletionFuture is an autogenerated mock type for the CompletionFuture type
+type MockCompletionFuture struct {
+ mock.Mock
+}
+
+type MockCompletionFuture_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockCompletionFuture) EXPECT() *MockCompletionFuture_Expecter {
+ return &MockCompletionFuture_Expecter{mock: &_m.Mock}
+}
+
+// AwaitCompletion provides a mock function with given fields: ctx
+func (_m *MockCompletionFuture) AwaitCompletion(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
+}
+
+// MockCompletionFuture_AwaitCompletion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AwaitCompletion'
+type MockCompletionFuture_AwaitCompletion_Call struct {
+ *mock.Call
+}
+
+// AwaitCompletion is a helper method to define mock.On call
+// - ctx context.Context
+func (_e *MockCompletionFuture_Expecter) AwaitCompletion(ctx interface{}) *MockCompletionFuture_AwaitCompletion_Call {
+ return &MockCompletionFuture_AwaitCompletion_Call{Call: _e.mock.On("AwaitCompletion", ctx)}
+}
+
+func (_c *MockCompletionFuture_AwaitCompletion_Call) Run(run func(ctx context.Context)) *MockCompletionFuture_AwaitCompletion_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context))
+ })
+ return _c
+}
+
+func (_c *MockCompletionFuture_AwaitCompletion_Call) Return(_a0 error) *MockCompletionFuture_AwaitCompletion_Call {
+ _c.Call.Return(_a0)
+ return _c
+}
+
+func (_c *MockCompletionFuture_AwaitCompletion_Call) RunAndReturn(run func(context.Context) error) *MockCompletionFuture_AwaitCompletion_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// Cancel provides a mock function with given fields: interrupt, err
+func (_m *MockCompletionFuture) Cancel(interrupt bool, err error) {
+ _m.Called(interrupt, err)
+}
+
+// MockCompletionFuture_Cancel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cancel'
+type MockCompletionFuture_Cancel_Call struct {
+ *mock.Call
+}
+
+// Cancel is a helper method to define mock.On call
+// - interrupt bool
+// - err error
+func (_e *MockCompletionFuture_Expecter) Cancel(interrupt interface{}, err interface{}) *MockCompletionFuture_Cancel_Call {
+ return &MockCompletionFuture_Cancel_Call{Call: _e.mock.On("Cancel", interrupt, err)}
+}
+
+func (_c *MockCompletionFuture_Cancel_Call) Run(run func(interrupt bool, err error)) *MockCompletionFuture_Cancel_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(bool), args[1].(error))
+ })
+ return _c
+}
+
+func (_c *MockCompletionFuture_Cancel_Call) Return() *MockCompletionFuture_Cancel_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockCompletionFuture_Cancel_Call) RunAndReturn(run func(bool, error)) *MockCompletionFuture_Cancel_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+type mockConstructorTestingTNewMockCompletionFuture interface {
+ mock.TestingT
+ Cleanup(func())
+}
+
+// NewMockCompletionFuture creates a new instance of MockCompletionFuture. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMockCompletionFuture(t mockConstructorTestingTNewMockCompletionFuture) *MockCompletionFuture {
+ mock := &MockCompletionFuture{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/plc4go/spi/mock_requirements.go b/plc4go/spi/mock_requirements.go
new file mode 100644
index 0000000000..c19da79323
--- /dev/null
+++ b/plc4go/spi/mock_requirements.go
@@ -0,0 +1,31 @@
+/*
+ * 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 spi
+
+import (
+ "github.com/apache/plc4x/plc4go/spi/utils"
+)
+
+// Note this file is a Helper for mockery to generate use mocks from other package
+
+// Deprecated: don't use it in productive code
+type CompletionFuture interface {
+ utils.CompletionFuture
+}