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/02 10:25:58 UTC
[plc4x] branch develop updated: test(plc4go/cbus): more tests for Driver
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 5156d9d7eb test(plc4go/cbus): more tests for Driver
5156d9d7eb is described below
commit 5156d9d7ebd0fba317731b959f8a0d7f631cc29c
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue May 2 12:25:48 2023 +0200
test(plc4go/cbus): more tests for Driver
---
plc4go/internal/cbus/Driver.go | 36 +++----
plc4go/internal/cbus/DriverContext.go | 4 +-
plc4go/internal/cbus/DriverContext_test.go | 6 +-
plc4go/internal/cbus/Driver_test.go | 150 +++++++++++++++++++++++++++--
plc4go/spi/transports/test/Transport.go | 5 +-
5 files changed, 161 insertions(+), 40 deletions(-)
diff --git a/plc4go/internal/cbus/Driver.go b/plc4go/internal/cbus/Driver.go
index 3a4facc222..bd3e75a024 100644
--- a/plc4go/internal/cbus/Driver.go
+++ b/plc4go/internal/cbus/Driver.go
@@ -58,11 +58,7 @@ func (m *Driver) GetConnectionWithContext(ctx context.Context, transportUrl url.
transport, ok := transports[transportUrl.Scheme]
if !ok {
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
- ch := make(chan plc4go.PlcConnectionConnectResult)
- go func() {
- ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
- }()
- return ch
+ return m.reportError(errors.Errorf("couldn't find transport for given transport url %v", transportUrl))
}
// Provide a default-port to the transport, which is used, if the user doesn't provide on in the connection string.
options["defaultTcpPort"] = []string{strconv.FormatUint(uint64(readWriteModel.CBusConstants_CBUSTCPDEFAULTPORT), 10)}
@@ -70,35 +66,19 @@ func (m *Driver) GetConnectionWithContext(ctx context.Context, transportUrl url.
transportInstance, err := transport.CreateTransportInstance(transportUrl, options)
if err != nil {
log.Error().Err(err).Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultTcpPort"])
- ch := make(chan plc4go.PlcConnectionConnectResult)
- go func() {
- ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
- }()
- return ch
+ return m.reportError(errors.Wrapf(err, "couldn't initialize transport configuration for given transport url %s", transportUrl.String()))
}
configuration, err := ParseFromOptions(options)
if err != nil {
log.Error().Err(err).Msgf("Invalid options")
- ch := make(chan plc4go.PlcConnectionConnectResult)
- go func() {
- ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
- }()
- return ch
+ return m.reportError(errors.Wrap(err, "Invalid options"))
}
codec := NewMessageCodec(transportInstance)
log.Debug().Msgf("working with codec %#v", codec)
- driverContext, err := NewDriverContext(configuration)
- if err != nil {
- log.Error().Err(err).Msgf("Invalid options")
- ch := make(chan plc4go.PlcConnectionConnectResult)
- go func() {
- ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
- }()
- return ch
- }
+ driverContext := NewDriverContext(configuration)
driverContext.awaitSetupComplete = m.awaitSetupComplete
driverContext.awaitDisconnectComplete = m.awaitDisconnectComplete
@@ -108,6 +88,14 @@ func (m *Driver) GetConnectionWithContext(ctx context.Context, transportUrl url.
return connection.ConnectWithContext(ctx)
}
+func (m *Driver) reportError(err error) <-chan plc4go.PlcConnectionConnectResult {
+ ch := make(chan plc4go.PlcConnectionConnectResult)
+ go func() {
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, err)
+ }()
+ return ch
+}
+
func (m *Driver) SetAwaitSetupComplete(awaitComplete bool) {
m.awaitSetupComplete = awaitComplete
}
diff --git a/plc4go/internal/cbus/DriverContext.go b/plc4go/internal/cbus/DriverContext.go
index 2c02a08d6a..069b817eb7 100644
--- a/plc4go/internal/cbus/DriverContext.go
+++ b/plc4go/internal/cbus/DriverContext.go
@@ -24,6 +24,6 @@ type DriverContext struct {
awaitDisconnectComplete bool
}
-func NewDriverContext(configuration Configuration) (DriverContext, error) {
- return DriverContext{}, nil
+func NewDriverContext(configuration Configuration) DriverContext {
+ return DriverContext{}
}
diff --git a/plc4go/internal/cbus/DriverContext_test.go b/plc4go/internal/cbus/DriverContext_test.go
index 2c5fa50294..a8bb5982db 100644
--- a/plc4go/internal/cbus/DriverContext_test.go
+++ b/plc4go/internal/cbus/DriverContext_test.go
@@ -20,7 +20,6 @@
package cbus
import (
- "fmt"
"github.com/stretchr/testify/assert"
"testing"
)
@@ -43,10 +42,7 @@ func TestNewDriverContext(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- got, err := NewDriverContext(tt.args.configuration)
- if !tt.wantErr(t, err, fmt.Sprintf("NewDriverContext(%v)", tt.args.configuration)) {
- return
- }
+ got := NewDriverContext(tt.args.configuration)
assert.Equalf(t, tt.want, got, "NewDriverContext(%v)", tt.args.configuration)
})
}
diff --git a/plc4go/internal/cbus/Driver_test.go b/plc4go/internal/cbus/Driver_test.go
index e88f342b48..0c2ad3b676 100644
--- a/plc4go/internal/cbus/Driver_test.go
+++ b/plc4go/internal/cbus/Driver_test.go
@@ -29,9 +29,12 @@ import (
"github.com/apache/plc4x/plc4go/spi/options"
"github.com/apache/plc4x/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/spi/transports/test"
+ "github.com/apache/plc4x/plc4go/spi/utils"
+ "github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"net/url"
"testing"
+ "time"
)
func TestDriver_DiscoverWithContext(t *testing.T) {
@@ -94,7 +97,7 @@ func TestDriver_GetConnectionWithContext(t *testing.T) {
name string
fields fields
args args
- wantVerifier func(t *testing.T, result <-chan plc4go.PlcConnectionConnectResult) bool
+ wantVerifier func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool
}{
{
name: "get connection transport not found",
@@ -112,12 +115,87 @@ func TestDriver_GetConnectionWithContext(t *testing.T) {
transports: map[string]transports.Transport{},
options: map[string][]string{},
},
- wantVerifier: func(t *testing.T, result <-chan plc4go.PlcConnectionConnectResult) bool {
- connectResult := <-result
- assert.NotNil(t, connectResult)
+ wantVerifier: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
+ timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
+ select {
+ case <-timeout.C:
+ t.Error("timeout")
+ return false
+ case result := <-results:
+ assert.Error(t, result.GetErr())
+ }
return true
},
- }, {
+ },
+ {
+ name: "get connection invalid options for transport",
+ fields: fields{
+ DefaultDriver: _default.NewDefaultDriver(nil, "test", "test", "test", NewTagHandler()),
+ tm: nil,
+ awaitSetupComplete: false,
+ awaitDisconnectComplete: false,
+ },
+ args: args{
+ ctx: context.Background(),
+ transportUrl: url.URL{
+ Scheme: "test",
+ },
+ transports: map[string]transports.Transport{
+ "test": test.NewTransport(),
+ },
+ options: map[string][]string{
+ "failTestTransport": {"yesSir"},
+ },
+ },
+ wantVerifier: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
+ timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
+ select {
+ case <-timeout.C:
+ t.Error("timeout")
+ return false
+ case result := <-results:
+ assert.Error(t, result.GetErr())
+ assert.Equal(t, "couldn't initialize transport configuration for given transport url test:: test transport failed on purpose", result.GetErr().Error())
+ }
+ return true
+ },
+ },
+ {
+ name: "get connection invalid options for driver",
+ fields: fields{
+ DefaultDriver: _default.NewDefaultDriver(nil, "test", "test", "test", NewTagHandler()),
+ tm: nil,
+ awaitSetupComplete: false,
+ awaitDisconnectComplete: false,
+ },
+ args: args{
+ ctx: context.Background(),
+ transportUrl: url.URL{
+ Scheme: "test",
+ },
+ transports: map[string]transports.Transport{
+ "test": test.NewTransport(),
+ },
+ options: map[string][]string{
+ "MonitoredApplication1": {"pineapple"},
+ },
+ },
+ wantVerifier: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
+ timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
+ select {
+ case <-timeout.C:
+ t.Error("timeout")
+ return false
+ case result := <-results:
+ assert.Error(t, result.GetErr())
+ }
+ return true
+ },
+ },
+ {
name: "get connection",
fields: fields{
DefaultDriver: _default.NewDefaultDriver(nil, "test", "test", "test", NewTagHandler()),
@@ -135,9 +213,17 @@ func TestDriver_GetConnectionWithContext(t *testing.T) {
},
options: map[string][]string{},
},
- wantVerifier: func(t *testing.T, result <-chan plc4go.PlcConnectionConnectResult) bool {
- connectResult := <-result
- assert.NotNil(t, connectResult)
+ wantVerifier: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
+ timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
+ select {
+ case <-timeout.C:
+ t.Error("timeout")
+ return false
+ case result := <-results:
+ assert.NoError(t, result.GetErr())
+ assert.NotNil(t, result.GetConnection())
+ }
return true
},
},
@@ -183,3 +269,51 @@ func TestNewDriver(t *testing.T) {
})
}
}
+
+func TestDriver_reportError(t *testing.T) {
+ type fields struct {
+ DefaultDriver _default.DefaultDriver
+ tm spi.RequestTransactionManager
+ awaitSetupComplete bool
+ awaitDisconnectComplete bool
+ }
+ type args struct {
+ err error
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantAsserter func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool
+ }{
+ {
+ name: "report it",
+ args: args{
+ err: errors.New("No no no no no"),
+ },
+ wantAsserter: func(t *testing.T, results <-chan plc4go.PlcConnectionConnectResult) bool {
+ timeout := time.NewTimer(20 * time.Millisecond)
+ defer utils.CleanupTimer(timeout)
+ select {
+ case <-timeout.C:
+ t.Error("timeout")
+ return false
+ case result := <-results:
+ assert.Error(t, result.GetErr())
+ }
+ return true
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Driver{
+ DefaultDriver: tt.fields.DefaultDriver,
+ tm: tt.fields.tm,
+ awaitSetupComplete: tt.fields.awaitSetupComplete,
+ awaitDisconnectComplete: tt.fields.awaitDisconnectComplete,
+ }
+ assert.Truef(t, tt.wantAsserter(t, m.reportError(tt.args.err)), "reportError(%v)", tt.args.err)
+ })
+ }
+}
diff --git a/plc4go/spi/transports/test/Transport.go b/plc4go/spi/transports/test/Transport.go
index cdcc658611..63c776e6d8 100644
--- a/plc4go/spi/transports/test/Transport.go
+++ b/plc4go/spi/transports/test/Transport.go
@@ -46,7 +46,10 @@ func (m *Transport) GetTransportName() string {
return "Test Transport"
}
-func (m *Transport) CreateTransportInstance(transportUrl url.URL, _ map[string][]string) (transports.TransportInstance, error) {
+func (m *Transport) CreateTransportInstance(transportUrl url.URL, options map[string][]string) (transports.TransportInstance, error) {
+ if _, ok := options["failTestTransport"]; ok {
+ return nil, errors.New("test transport failed on purpose")
+ }
if preregisteredInstance, ok := m.preregisteredInstances[transportUrl]; ok {
log.Trace().Msgf("Returning pre registered instance for %v", transportUrl)
return preregisteredInstance, nil