From 5c895919bbe291998725ac5bcc5fca0f0c356922 Mon Sep 17 00:00:00 2001 From: Thomas Kohler Date: Sat, 10 Feb 2024 17:49:01 +0100 Subject: [PATCH] ble: add support for functional options, add tests --- README.md | 3 +- adaptor.go | 2 +- doc.go | 3 +- driver.go | 2 +- drivers/MIGRATION.md | 38 ++++ drivers/ble/battery_driver.go | 12 +- drivers/ble/battery_driver_test.go | 23 ++- drivers/ble/ble_driver.go | 18 +- drivers/ble/ble_driver_test.go | 30 +++ drivers/ble/device_information_driver.go | 40 ++-- drivers/ble/device_information_driver_test.go | 50 ++++- drivers/ble/generic_access_driver.go | 21 +- drivers/ble/generic_access_driver_test.go | 30 ++- drivers/ble/microbit/accelerometer_driver.go | 6 +- .../ble/microbit/accelerometer_driver_test.go | 15 +- drivers/ble/microbit/button_driver.go | 8 +- drivers/ble/microbit/button_driver_test.go | 15 +- drivers/ble/microbit/io_pin_driver.go | 4 +- drivers/ble/microbit/io_pin_driver_test.go | 13 ++ drivers/ble/microbit/led_driver.go | 4 +- drivers/ble/microbit/led_driver_test.go | 13 ++ drivers/ble/microbit/magnetometer_driver.go | 6 +- .../ble/microbit/magnetometer_driver_test.go | 15 +- drivers/ble/microbit/temperature_driver.go | 6 +- .../ble/microbit/temperature_driver_test.go | 19 +- drivers/ble/parrot/minidrone_driver.go | 8 +- drivers/ble/parrot/minidrone_driver_test.go | 13 ++ drivers/ble/serial_port.go | 6 +- drivers/ble/serial_port_test.go | 190 +++++++++++++++++- drivers/ble/sphero/sphero_bb8_driver.go | 5 +- drivers/ble/sphero/sphero_bb8_driver_test.go | 13 ++ drivers/ble/sphero/sphero_ollie_driver.go | 13 +- .../ble/sphero/sphero_ollie_driver_test.go | 19 +- drivers/ble/sphero/sphero_sprkplus_driver.go | 5 +- .../ble/sphero/sphero_sprkplus_driver_test.go | 13 ++ drivers/ble/testutil/testutil.go | 52 ++++- drivers/serial/serial_driver.go | 8 +- drivers/serial/serial_driver_test.go | 15 ++ drivers/serial/sphero_driver.go | 4 +- drivers/serial/sphero_driver_test.go | 12 ++ examples/ble_battery.go | 6 +- examples/ble_device_info.go | 34 +++- examples/ble_generic_access.go | 13 +- examples/ble_multiple_generic.go | 13 +- examples/ble_multiple_info.go | 34 +++- examples/serial_sphero_conways.go | 3 +- examples/serial_sphero_multiple.go | 3 +- platforms/bleclient/README.md | 6 +- platforms/bleclient/ble_client_adaptor.go | 7 +- platforms/serialport/adaptor_test.go | 38 ++-- 50 files changed, 768 insertions(+), 161 deletions(-) diff --git a/README.md b/README.md index c8b524320..7970c30f5 100644 --- a/README.md +++ b/README.md @@ -174,8 +174,7 @@ import ( func NewSwarmBot(port string) *gobot.Robot { spheroAdaptor := serialport.NewAdaptor(port) - spheroDriver := serial.NewSpheroDriver(spheroAdaptor) - spheroDriver.SetName("Sphero" + port) + spheroDriver := serial.NewSpheroDriver(spheroAdaptor, serial.WithName("Sphero" + port)) work := func() { spheroDriver.Stop() diff --git a/adaptor.go b/adaptor.go index 6eedb50cb..cb66b8315 100644 --- a/adaptor.go +++ b/adaptor.go @@ -235,7 +235,7 @@ type BLEConnector interface { ReadCharacteristic(cUUID string) ([]byte, error) WriteCharacteristic(cUUID string, data []byte) error - Subscribe(cUUID string, f func([]byte, error)) error + Subscribe(cUUID string, f func(data []byte)) error WithoutResponses(use bool) } diff --git a/doc.go b/doc.go index 2f1eee92a..e20fe04e6 100644 --- a/doc.go +++ b/doc.go @@ -85,8 +85,7 @@ Finally, you can use Master Gobot to add the complete Gobot API or control swarm func NewSwarmBot(port string) *gobot.Robot { spheroAdaptor := serialport.NewAdaptor(port) - spheroDriver := serial.NewSpheroDriver(spheroAdaptor) - spheroDriver.SetName("Sphero" + port) + spheroDriver := serial.NewSpheroDriver(spheroAdaptor, serial.WithName("Sphero" + port)) work := func() { spheroDriver.Stop() diff --git a/driver.go b/driver.go index 7581f2826..650de09b3 100644 --- a/driver.go +++ b/driver.go @@ -5,7 +5,7 @@ type Driver interface { // Name returns the label for the Driver Name() string // SetName sets the label for the Driver. - // Please prefer to use options [gpio.WithName or aio.WithName] instead, if possible. + // Please use options [aio.WithName, ble.WithName, gpio.WithName or serial.WithName] instead. SetName(s string) // Start initiates the Driver Start() error diff --git a/drivers/MIGRATION.md b/drivers/MIGRATION.md index 2d80d434d..5f5cabdcf 100644 --- a/drivers/MIGRATION.md +++ b/drivers/MIGRATION.md @@ -39,6 +39,44 @@ import( ... ``` +### BLE client adaptor changed signature for Subscribe() + +Since introducing the usage of "github.com/muka/go-bluetooth" in 2020, the callback do not support the given error +parameter anymore. The switch to usage of "tinygo.org/x/bluetooth" has not changed this. Therefore it is removed now +from the function. + +### BLE generic drivers changed signature for Get*() functions + +All those functions log an error only or panic, so the caller gets no nice programmatic feedback. The error is now +returned instead and the log output needs to be done at caller side. + +```go +// old +... + devName := access.GetDeviceName() + appearance := access.GetAppearance() + modelNo := info.GetModelNumber() + fwRev := info.GetFirmwareRevision() + hwRev := info.GetHardwareRevision() + manuName := info.GetManufacturerName() + pid := info.GetPnPId() + level := battery.GetBatteryLevel() +... + +// new +... + devName, err := access.GetDeviceName() + if err != nil { + fmt.Println(err) + } + appearance, err := access.GetAppearance() + if err != nil { + fmt.Println(err) + } + ... +... +``` + ### Sphero adaptor split off The Serial Based Sphero adaptor was split off into a generic serial adaptor and the driver part. With this, the imports diff --git a/drivers/ble/battery_driver.go b/drivers/ble/battery_driver.go index f97ecafef..9ce222c9c 100644 --- a/drivers/ble/battery_driver.go +++ b/drivers/ble/battery_driver.go @@ -2,7 +2,6 @@ package ble import ( "bytes" - "log" "gobot.io/x/gobot/v2" ) @@ -16,9 +15,9 @@ type BatteryDriver struct { } // NewBatteryDriver creates a new driver -func NewBatteryDriver(a gobot.BLEConnector) *BatteryDriver { +func NewBatteryDriver(a gobot.BLEConnector, opts ...OptionApplier) *BatteryDriver { d := &BatteryDriver{ - Driver: NewDriver(a, "Battery", nil, nil), + Driver: NewDriver(a, "Battery", nil, nil, opts...), Eventer: gobot.NewEventer(), } @@ -26,14 +25,13 @@ func NewBatteryDriver(a gobot.BLEConnector) *BatteryDriver { } // GetBatteryLevel reads and returns the current battery level -func (d *BatteryDriver) GetBatteryLevel() uint8 { +func (d *BatteryDriver) GetBatteryLevel() (uint8, error) { c, err := d.Adaptor().ReadCharacteristic(batteryCharaShort) if err != nil { - log.Println(err) - return 0 + return 0, err } buf := bytes.NewBuffer(c) val, _ := buf.ReadByte() level := val - return level + return level, nil } diff --git a/drivers/ble/battery_driver_test.go b/drivers/ble/battery_driver_test.go index 6495317ff..9fe9f5f63 100644 --- a/drivers/ble/battery_driver_test.go +++ b/drivers/ble/battery_driver_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" "gobot.io/x/gobot/v2/drivers/ble/testutil" @@ -13,12 +14,27 @@ import ( var _ gobot.Driver = (*BatteryDriver)(nil) func TestNewBatteryDriver(t *testing.T) { + // arrange d := NewBatteryDriver(testutil.NewBleTestAdaptor()) + // act & assert assert.True(t, strings.HasPrefix(d.Name(), "Battery")) assert.NotNil(t, d.Eventer) } +func TestNewBatteryDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewBatteryDriver(a, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestBatteryDriverRead(t *testing.T) { + // arrange a := testutil.NewBleTestAdaptor() d := NewBatteryDriver(a) a.SetReadCharacteristicTestFunc(func(cUUID string) ([]byte, error) { @@ -28,6 +44,9 @@ func TestBatteryDriverRead(t *testing.T) { return nil, nil }) - - assert.Equal(t, uint8(20), d.GetBatteryLevel()) + // act + level, err := d.GetBatteryLevel() + // assert + require.NoError(t, err) + assert.Equal(t, uint8(20), level) } diff --git a/drivers/ble/ble_driver.go b/drivers/ble/ble_driver.go index e1b766b36..3634cbe8a 100644 --- a/drivers/ble/ble_driver.go +++ b/drivers/ble/ble_driver.go @@ -7,8 +7,8 @@ import ( "gobot.io/x/gobot/v2" ) -// optionApplier needs to be implemented by each configurable option type -type optionApplier interface { +// OptionApplier needs to be implemented by each configurable option type +type OptionApplier interface { apply(cfg *configuration) } @@ -31,7 +31,11 @@ type Driver struct { } // NewDriver creates a new basic BLE gobot driver. -func NewDriver(a interface{}, name string, afterStart func() error, beforeHalt func() error) *Driver { +func NewDriver( + a interface{}, name string, + afterStart func() error, beforeHalt func() error, + opts ...OptionApplier, +) *Driver { if afterStart == nil { afterStart = func() error { return nil } } @@ -49,11 +53,15 @@ func NewDriver(a interface{}, name string, afterStart func() error, beforeHalt f mutex: &sync.Mutex{}, } + for _, o := range opts { + o.apply(d.driverCfg) + } + return &d } // WithName is used to replace the default name of the driver. -func WithName(name string) optionApplier { +func WithName(name string) OptionApplier { return nameOption(name) } @@ -63,7 +71,7 @@ func (d *Driver) Name() string { } // SetName sets the name of the driver. -// Deprecated: Please use option [aio.WithName] instead. +// Deprecated: Please use option [ble.WithName] instead. func (d *Driver) SetName(name string) { WithName(name).apply(d.driverCfg) } diff --git a/drivers/ble/ble_driver_test.go b/drivers/ble/ble_driver_test.go index 5e40f313b..14cf1dbbd 100644 --- a/drivers/ble/ble_driver_test.go +++ b/drivers/ble/ble_driver_test.go @@ -37,6 +37,21 @@ func TestNewDriver(t *testing.T) { assert.NotNil(t, d.mutex) } +func TestNewDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const ( + name = "mybot" + newName = "overwrite mybot" + ) + a := testutil.NewBleTestAdaptor() + // act + d := NewDriver(a, name, nil, nil, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func Test_applyWithName(t *testing.T) { // arrange const name = "mybot" @@ -68,3 +83,18 @@ func TestHalt(t *testing.T) { // act, assert require.EqualError(t, d.Halt(), "before halt error") } + +func TestAdaptor(t *testing.T) { + wrongConnectorType := struct { + a uint32 + }{} + // arrange + a := testutil.NewBleTestAdaptor() + d := NewDriver(a, "BLE_BASIC", nil, nil) + // act, assert + assert.Equal(t, a, d.Adaptor()) + // arrange wrong connector type + d.connection = wrongConnectorType + // act, assert + assert.Nil(t, d.Adaptor()) +} diff --git a/drivers/ble/device_information_driver.go b/drivers/ble/device_information_driver.go index 8eca3c21b..ef6949df7 100644 --- a/drivers/ble/device_information_driver.go +++ b/drivers/ble/device_information_driver.go @@ -2,7 +2,6 @@ package ble import ( "bytes" - "log" "gobot.io/x/gobot/v2" ) @@ -22,9 +21,9 @@ type DeviceInformationDriver struct { } // NewDeviceInformationDriver creates a new driver -func NewDeviceInformationDriver(a gobot.BLEConnector) *DeviceInformationDriver { +func NewDeviceInformationDriver(a gobot.BLEConnector, opts ...OptionApplier) *DeviceInformationDriver { n := &DeviceInformationDriver{ - Driver: NewDriver(a, "DeviceInformation", nil, nil), + Driver: NewDriver(a, "DeviceInformation", nil, nil, opts...), Eventer: gobot.NewEventer(), } @@ -32,61 +31,56 @@ func NewDeviceInformationDriver(a gobot.BLEConnector) *DeviceInformationDriver { } // GetModelNumber returns the model number for the BLE Peripheral -func (d *DeviceInformationDriver) GetModelNumber() string { +func (d *DeviceInformationDriver) GetModelNumber() (string, error) { c, err := d.Adaptor().ReadCharacteristic(deviceInformationModelNumberCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) model := buf.String() - return model + return model, nil } // GetFirmwareRevision returns the firmware revision for the BLE Peripheral -func (d *DeviceInformationDriver) GetFirmwareRevision() string { +func (d *DeviceInformationDriver) GetFirmwareRevision() (string, error) { c, err := d.Adaptor().ReadCharacteristic(deviceInformationFirmwareRevisionCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) val := buf.String() - return val + return val, nil } // GetHardwareRevision returns the hardware revision for the BLE Peripheral -func (d *DeviceInformationDriver) GetHardwareRevision() string { +func (d *DeviceInformationDriver) GetHardwareRevision() (string, error) { c, err := d.Adaptor().ReadCharacteristic(deviceInformationHardwareRevisionCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) val := buf.String() - return val + return val, nil } // GetManufacturerName returns the manufacturer name for the BLE Peripheral -func (d *DeviceInformationDriver) GetManufacturerName() string { +func (d *DeviceInformationDriver) GetManufacturerName() (string, error) { c, err := d.Adaptor().ReadCharacteristic(deviceInformationManufacturerNameCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) val := buf.String() - return val + return val, nil } // GetPnPId returns the PnP ID for the BLE Peripheral -func (d *DeviceInformationDriver) GetPnPId() string { +func (d *DeviceInformationDriver) GetPnPId() (string, error) { c, err := d.Adaptor().ReadCharacteristic(deviceInformationPnPIdCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) val := buf.String() - return val + return val, nil } diff --git a/drivers/ble/device_information_driver_test.go b/drivers/ble/device_information_driver_test.go index 976849e6c..38f362b5b 100644 --- a/drivers/ble/device_information_driver_test.go +++ b/drivers/ble/device_information_driver_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" "gobot.io/x/gobot/v2/drivers/ble/testutil" @@ -13,32 +14,71 @@ import ( var _ gobot.Driver = (*DeviceInformationDriver)(nil) func TestNewDeviceInformationDriver(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) + // act & assert assert.True(t, strings.HasPrefix(d.Name(), "DeviceInformation")) assert.NotNil(t, d.Eventer) } +func TestNewDeviceInformationDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewDeviceInformationDriver(a, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestDeviceInformationGetModelNumber(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a24", d.GetModelNumber()) + // act + modelNo, err := d.GetModelNumber() + // assert + require.NoError(t, err) + assert.Equal(t, "2a24", modelNo) } func TestDeviceInformationGetFirmwareRevision(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a26", d.GetFirmwareRevision()) + // act + fwRev, err := d.GetFirmwareRevision() + // assert + require.NoError(t, err) + assert.Equal(t, "2a26", fwRev) } func TestDeviceInformationGetHardwareRevision(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a27", d.GetHardwareRevision()) + // act + hwRev, err := d.GetHardwareRevision() + // assert + require.NoError(t, err) + assert.Equal(t, "2a27", hwRev) } func TestDeviceInformationGetManufacturerName(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a29", d.GetManufacturerName()) + // act + manuName, err := d.GetManufacturerName() + // assert + require.NoError(t, err) + assert.Equal(t, "2a29", manuName) } func TestDeviceInformationGetPnPId(t *testing.T) { + // arrange d := NewDeviceInformationDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a50", d.GetPnPId()) + // act + pid, err := d.GetPnPId() + // assert + require.NoError(t, err) + assert.Equal(t, "2a50", pid) } diff --git a/drivers/ble/generic_access_driver.go b/drivers/ble/generic_access_driver.go index 776db09ce..cdf89a298 100644 --- a/drivers/ble/generic_access_driver.go +++ b/drivers/ble/generic_access_driver.go @@ -3,7 +3,6 @@ package ble import ( "bytes" "encoding/binary" - "log" "gobot.io/x/gobot/v2" ) @@ -20,9 +19,9 @@ type GenericAccessDriver struct { } // NewGenericAccessDriver creates a GenericAccessDriver -func NewGenericAccessDriver(a gobot.BLEConnector) *GenericAccessDriver { +func NewGenericAccessDriver(a gobot.BLEConnector, opts ...OptionApplier) *GenericAccessDriver { d := &GenericAccessDriver{ - Driver: NewDriver(a, "GenericAccess", nil, nil), + Driver: NewDriver(a, "GenericAccess", nil, nil, opts...), Eventer: gobot.NewEventer(), } @@ -30,33 +29,31 @@ func NewGenericAccessDriver(a gobot.BLEConnector) *GenericAccessDriver { } // GetDeviceName returns the device name for the BLE Peripheral -func (d *GenericAccessDriver) GetDeviceName() string { +func (d *GenericAccessDriver) GetDeviceName() (string, error) { c, err := d.Adaptor().ReadCharacteristic(genericAccessDeviceNameCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) val := buf.String() - return val + return val, nil } // GetAppearance returns the appearance string for the BLE Peripheral -func (d *GenericAccessDriver) GetAppearance() string { +func (d *GenericAccessDriver) GetAppearance() (string, error) { c, err := d.Adaptor().ReadCharacteristic(genericAccessAppearanceCharaShort) if err != nil { - log.Println(err) - return "" + return "", err } buf := bytes.NewBuffer(c) var val uint16 if err := binary.Read(buf, binary.LittleEndian, &val); err != nil { - panic(err) + return "", err } - return appearances[val] + return appearances[val], nil } var appearances = map[uint16]string{ diff --git a/drivers/ble/generic_access_driver_test.go b/drivers/ble/generic_access_driver_test.go index 845cc5881..50d7a65c5 100644 --- a/drivers/ble/generic_access_driver_test.go +++ b/drivers/ble/generic_access_driver_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" "gobot.io/x/gobot/v2/drivers/ble/testutil" @@ -13,17 +14,37 @@ import ( var _ gobot.Driver = (*GenericAccessDriver)(nil) func TestNewGenericAccessDriver(t *testing.T) { + // arrange d := NewGenericAccessDriver(testutil.NewBleTestAdaptor()) + // act assert.True(t, strings.HasPrefix(d.Name(), "GenericAccess")) assert.NotNil(t, d.Eventer) } +func TestNewGenericAccessDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewGenericAccessDriver(a, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestGenericAccessDriverGetDeviceName(t *testing.T) { + // arrange d := NewGenericAccessDriver(testutil.NewBleTestAdaptor()) - assert.Equal(t, "2a00", d.GetDeviceName()) + // act + devName, err := d.GetDeviceName() + // assert + require.NoError(t, err) + assert.Equal(t, "2a00", devName) } func TestGenericAccessDriverGetAppearance(t *testing.T) { + // arrange a := testutil.NewBleTestAdaptor() d := NewGenericAccessDriver(a) a.SetReadCharacteristicTestFunc(func(cUUID string) ([]byte, error) { @@ -32,6 +53,9 @@ func TestGenericAccessDriverGetAppearance(t *testing.T) { } return nil, nil }) - - assert.Equal(t, "Generic Computer", d.GetAppearance()) + // act + app, err := d.GetAppearance() + // assert + require.NoError(t, err) + assert.Equal(t, "Generic Computer", app) } diff --git a/drivers/ble/microbit/accelerometer_driver.go b/drivers/ble/microbit/accelerometer_driver.go index 634bee816..9ffe4c732 100644 --- a/drivers/ble/microbit/accelerometer_driver.go +++ b/drivers/ble/microbit/accelerometer_driver.go @@ -28,11 +28,11 @@ type AccelerometerData struct { } // NewAccelerometerDriver creates a AccelerometerDriver -func NewAccelerometerDriver(a gobot.BLEConnector) *AccelerometerDriver { +func NewAccelerometerDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *AccelerometerDriver { d := &AccelerometerDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit Accelerometer", d.initialize, nil) + d.Driver = ble.NewDriver(a, "Microbit Accelerometer", d.initialize, nil, opts...) d.AddEvent(AccelerometerEvent) @@ -42,7 +42,7 @@ func NewAccelerometerDriver(a gobot.BLEConnector) *AccelerometerDriver { // initialize tells driver to get ready to do work func (d *AccelerometerDriver) initialize() error { // subscribe to accelerometer notifications - return d.Adaptor().Subscribe(accelerometerChara, func(data []byte, e error) { + return d.Adaptor().Subscribe(accelerometerChara, func(data []byte) { a := struct{ x, y, z int16 }{x: 0, y: 0, z: 0} buf := bytes.NewBuffer(data) diff --git a/drivers/ble/microbit/accelerometer_driver_test.go b/drivers/ble/microbit/accelerometer_driver_test.go index fd59c2528..f0db11a3d 100644 --- a/drivers/ble/microbit/accelerometer_driver_test.go +++ b/drivers/ble/microbit/accelerometer_driver_test.go @@ -10,6 +10,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -22,6 +23,18 @@ func TestNewAccelerometerDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewAccelerometerDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewAccelerometerDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestAccelerometerStartAndHalt(t *testing.T) { d := NewAccelerometerDriver(testutil.NewBleTestAdaptor()) require.NoError(t, d.Start()) @@ -43,7 +56,7 @@ func TestAccelerometerReadData(t *testing.T) { require.NoError(t, err) - a.SendTestDataToSubscriber([]byte{0x22, 0x22, 0x23, 0x23, 0x24, 0x24}, nil) + a.SendTestDataToSubscriber([]byte{0x22, 0x22, 0x23, 0x23, 0x24, 0x24}) select { case <-sem: diff --git a/drivers/ble/microbit/button_driver.go b/drivers/ble/microbit/button_driver.go index a095f3828..e0b2c7bbb 100644 --- a/drivers/ble/microbit/button_driver.go +++ b/drivers/ble/microbit/button_driver.go @@ -21,12 +21,12 @@ type ButtonDriver struct { } // NewButtonDriver creates a new driver -func NewButtonDriver(a gobot.BLEConnector) *ButtonDriver { +func NewButtonDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *ButtonDriver { d := &ButtonDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit Button", d.initialize, nil) + d.Driver = ble.NewDriver(a, "Microbit Button", d.initialize, nil, opts...) d.AddEvent(ButtonAEvent) d.AddEvent(ButtonBEvent) @@ -37,14 +37,14 @@ func NewButtonDriver(a gobot.BLEConnector) *ButtonDriver { // initialize tells driver to get ready to do work func (d *ButtonDriver) initialize() error { // subscribe to button A notifications - if err := d.Adaptor().Subscribe(buttonAChara, func(data []byte, e error) { + if err := d.Adaptor().Subscribe(buttonAChara, func(data []byte) { d.Publish(d.Event(ButtonAEvent), data) }); err != nil { return err } // subscribe to button B notifications - return d.Adaptor().Subscribe(buttonBChara, func(data []byte, e error) { + return d.Adaptor().Subscribe(buttonBChara, func(data []byte) { d.Publish(d.Event(ButtonBEvent), data) }) } diff --git a/drivers/ble/microbit/button_driver_test.go b/drivers/ble/microbit/button_driver_test.go index 886bc05e9..0e6303511 100644 --- a/drivers/ble/microbit/button_driver_test.go +++ b/drivers/ble/microbit/button_driver_test.go @@ -9,6 +9,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -21,6 +22,18 @@ func TestNewButtonDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewButtonDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewButtonDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestButtonStartAndHalt(t *testing.T) { d := NewButtonDriver(testutil.NewBleTestAdaptor()) require.NoError(t, d.Start()) @@ -38,7 +51,7 @@ func TestButtonReadData(t *testing.T) { }) require.NoError(t, err) - a.SendTestDataToSubscriber([]byte{1}, nil) + a.SendTestDataToSubscriber([]byte{1}) select { case <-sem: diff --git a/drivers/ble/microbit/io_pin_driver.go b/drivers/ble/microbit/io_pin_driver.go index 883568fc3..d45b2d6c2 100644 --- a/drivers/ble/microbit/io_pin_driver.go +++ b/drivers/ble/microbit/io_pin_driver.go @@ -33,12 +33,12 @@ type pinData struct { } // NewIOPinDriver creates a new driver -func NewIOPinDriver(a gobot.BLEConnector) *IOPinDriver { +func NewIOPinDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *IOPinDriver { d := &IOPinDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit IO Pins", d.initialize, nil) + d.Driver = ble.NewDriver(a, "Microbit IO Pins", d.initialize, nil, opts...) return d } diff --git a/drivers/ble/microbit/io_pin_driver_test.go b/drivers/ble/microbit/io_pin_driver_test.go index f73c1d27e..3bdce9f1e 100644 --- a/drivers/ble/microbit/io_pin_driver_test.go +++ b/drivers/ble/microbit/io_pin_driver_test.go @@ -10,6 +10,7 @@ import ( "gobot.io/x/gobot/v2" "gobot.io/x/gobot/v2/drivers/aio" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" "gobot.io/x/gobot/v2/drivers/gpio" ) @@ -31,6 +32,18 @@ func TestNewIOPinDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewIOPinDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewIOPinDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestIOPinStartAndHalt(t *testing.T) { a := testutil.NewBleTestAdaptor() d := NewIOPinDriver(a) diff --git a/drivers/ble/microbit/led_driver.go b/drivers/ble/microbit/led_driver.go index 3de8a5b30..7116c4671 100644 --- a/drivers/ble/microbit/led_driver.go +++ b/drivers/ble/microbit/led_driver.go @@ -19,12 +19,12 @@ type LEDDriver struct { } // NewLEDDriver creates a Microbit LEDDriver -func NewLEDDriver(a gobot.BLEConnector) *LEDDriver { +func NewLEDDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *LEDDriver { d := &LEDDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit LED", nil, nil) + d.Driver = ble.NewDriver(a, "Microbit LED", nil, nil, opts...) return d } diff --git a/drivers/ble/microbit/led_driver_test.go b/drivers/ble/microbit/led_driver_test.go index 18e09e7ef..a3ea15b55 100644 --- a/drivers/ble/microbit/led_driver_test.go +++ b/drivers/ble/microbit/led_driver_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -25,6 +26,18 @@ func TestNewLEDDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewLEDDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewLEDDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestLEDWriteMatrix(t *testing.T) { d := initTestLEDDriver() require.NoError(t, d.WriteMatrix([]byte{0x01, 0x02})) diff --git a/drivers/ble/microbit/magnetometer_driver.go b/drivers/ble/microbit/magnetometer_driver.go index 2fb8972e0..630762210 100644 --- a/drivers/ble/microbit/magnetometer_driver.go +++ b/drivers/ble/microbit/magnetometer_driver.go @@ -28,11 +28,11 @@ type MagnetometerData struct { } // NewMagnetometerDriver creates a Microbit MagnetometerDriver -func NewMagnetometerDriver(a gobot.BLEConnector) *MagnetometerDriver { +func NewMagnetometerDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *MagnetometerDriver { d := &MagnetometerDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit Magnetometer", d.initialize, nil) + d.Driver = ble.NewDriver(a, "Microbit Magnetometer", d.initialize, nil, opts...) d.AddEvent(MagnetometerEvent) @@ -42,7 +42,7 @@ func NewMagnetometerDriver(a gobot.BLEConnector) *MagnetometerDriver { // initialize tells driver to get ready to do work func (d *MagnetometerDriver) initialize() error { // subscribe to magnetometer notifications - return d.Adaptor().Subscribe(magnetometerChara, func(data []byte, e error) { + return d.Adaptor().Subscribe(magnetometerChara, func(data []byte) { a := struct{ x, y, z int16 }{x: 0, y: 0, z: 0} buf := bytes.NewBuffer(data) diff --git a/drivers/ble/microbit/magnetometer_driver_test.go b/drivers/ble/microbit/magnetometer_driver_test.go index 9cd098243..d2d8c6639 100644 --- a/drivers/ble/microbit/magnetometer_driver_test.go +++ b/drivers/ble/microbit/magnetometer_driver_test.go @@ -10,6 +10,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -27,6 +28,18 @@ func TestMagnetometerDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewMagnetometerDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewMagnetometerDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestMagnetometerStartAndHalt(t *testing.T) { d := initTestMagnetometerDriver() require.NoError(t, d.Start()) @@ -46,7 +59,7 @@ func TestMagnetometerReadData(t *testing.T) { }) require.NoError(t, err) - a.SendTestDataToSubscriber([]byte{0x22, 0x22, 0x23, 0x23, 0x24, 0x24}, nil) + a.SendTestDataToSubscriber([]byte{0x22, 0x22, 0x23, 0x23, 0x24, 0x24}) select { case <-sem: diff --git a/drivers/ble/microbit/temperature_driver.go b/drivers/ble/microbit/temperature_driver.go index 6eb6ac373..5e86a3249 100644 --- a/drivers/ble/microbit/temperature_driver.go +++ b/drivers/ble/microbit/temperature_driver.go @@ -21,11 +21,11 @@ type TemperatureDriver struct { } // NewTemperatureDriver creates a Microbit TemperatureDriver -func NewTemperatureDriver(a gobot.BLEConnector) *TemperatureDriver { +func NewTemperatureDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *TemperatureDriver { d := &TemperatureDriver{ Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Microbit Temperature", d.initialize, nil) + d.Driver = ble.NewDriver(a, "Microbit Temperature", d.initialize, nil, opts...) d.AddEvent(TemperatureEvent) @@ -35,7 +35,7 @@ func NewTemperatureDriver(a gobot.BLEConnector) *TemperatureDriver { // initialize tells driver to get ready to do work func (d *TemperatureDriver) initialize() error { // subscribe to temperature notifications - return d.Adaptor().Subscribe(temperatureChara, func(data []byte, e error) { + return d.Adaptor().Subscribe(temperatureChara, func(data []byte) { var l int8 buf := bytes.NewBuffer(data) val, _ := buf.ReadByte() diff --git a/drivers/ble/microbit/temperature_driver_test.go b/drivers/ble/microbit/temperature_driver_test.go index 070537ddd..ea8984b4c 100644 --- a/drivers/ble/microbit/temperature_driver_test.go +++ b/drivers/ble/microbit/temperature_driver_test.go @@ -9,6 +9,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -19,13 +20,25 @@ func initTestTemperatureDriver() *TemperatureDriver { return d } -func TestTemperatureDriver(t *testing.T) { - d := initTestTemperatureDriver() +func TestNewTemperatureDriver(t *testing.T) { + d := NewTemperatureDriver(testutil.NewBleTestAdaptor()) assert.IsType(t, &TemperatureDriver{}, d) assert.True(t, strings.HasPrefix(d.Name(), "Microbit Temperature")) assert.NotNil(t, d.Eventer) } +func TestNewTemperatureDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewTemperatureDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestTemperatureStartAndHalt(t *testing.T) { d := initTestTemperatureDriver() require.NoError(t, d.Start()) @@ -43,7 +56,7 @@ func TestTemperatureReadData(t *testing.T) { }) require.NoError(t, err) - a.SendTestDataToSubscriber([]byte{0x22}, nil) + a.SendTestDataToSubscriber([]byte{0x22}) select { case <-sem: diff --git a/drivers/ble/parrot/minidrone_driver.go b/drivers/ble/parrot/minidrone_driver.go index f1fee75cb..e42f1f370 100644 --- a/drivers/ble/parrot/minidrone_driver.go +++ b/drivers/ble/parrot/minidrone_driver.go @@ -81,7 +81,7 @@ type Pcmd struct { } // NewDriver creates a Parrot Minidrone Driver -func NewMinidroneDriver(a gobot.BLEConnector) *MinidroneDriver { +func NewMinidroneDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *MinidroneDriver { d := &MinidroneDriver{ Pcmd: Pcmd{ Flag: 0, @@ -93,7 +93,7 @@ func NewMinidroneDriver(a gobot.BLEConnector) *MinidroneDriver { }, Eventer: gobot.NewEventer(), } - d.Driver = ble.NewDriver(a, "Minidrone", d.initialize, d.shutdown) + d.Driver = ble.NewDriver(a, "Minidrone", d.initialize, d.shutdown, opts...) d.AddEvent(BatteryEvent) d.AddEvent(FlightStatusEvent) @@ -349,14 +349,14 @@ func (d *MinidroneDriver) initialize() error { } // subscribe to battery notifications - if err := d.Adaptor().Subscribe(batteryChara, func(data []byte, e error) { + if err := d.Adaptor().Subscribe(batteryChara, func(data []byte) { d.Publish(d.Event(BatteryEvent), data[len(data)-1]) }); err != nil { return err } // subscribe to flying status notifications - if err := d.Adaptor().Subscribe(flightStatusChara, func(data []byte, e error) { + if err := d.Adaptor().Subscribe(flightStatusChara, func(data []byte) { d.processFlightStatus(data) }); err != nil { return err diff --git a/drivers/ble/parrot/minidrone_driver_test.go b/drivers/ble/parrot/minidrone_driver_test.go index bbae0c67e..add322d30 100644 --- a/drivers/ble/parrot/minidrone_driver_test.go +++ b/drivers/ble/parrot/minidrone_driver_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -27,6 +28,18 @@ func TestNewMinidroneDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewMinidroneDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewMinidroneDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestMinidroneHalt(t *testing.T) { d := initTestMinidroneDriver() require.NoError(t, d.Halt()) diff --git a/drivers/ble/serial_port.go b/drivers/ble/serial_port.go index fbf7addcb..86aefe28c 100644 --- a/drivers/ble/serial_port.go +++ b/drivers/ble/serial_port.go @@ -18,9 +18,9 @@ type SerialPortDriver struct { } // NewSerialPortDriver returns a new serial over Bluetooth LE connection -func NewSerialPortDriver(a gobot.BLEConnector, rid string, tid string) *SerialPortDriver { +func NewSerialPortDriver(a gobot.BLEConnector, rid string, tid string, opts ...OptionApplier) *SerialPortDriver { d := &SerialPortDriver{ - Driver: NewDriver(a, "BleSerial", nil, nil), + Driver: NewDriver(a, "BleSerial", nil, nil, opts...), rid: rid, tid: tid, } @@ -35,7 +35,7 @@ func (p *SerialPortDriver) Open() error { } // subscribe to response notifications - return p.Adaptor().Subscribe(p.rid, func(data []byte, e error) { + return p.Adaptor().Subscribe(p.rid, func(data []byte) { p.responseMutex.Lock() defer p.responseMutex.Unlock() p.responseData = append(p.responseData, data...) diff --git a/drivers/ble/serial_port_test.go b/drivers/ble/serial_port_test.go index 1d045f3b1..9b2df6316 100644 --- a/drivers/ble/serial_port_test.go +++ b/drivers/ble/serial_port_test.go @@ -1,10 +1,12 @@ package ble import ( + "fmt" "io" "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" "gobot.io/x/gobot/v2/drivers/ble/testutil" @@ -14,7 +16,193 @@ var _ gobot.Driver = (*SerialPortDriver)(nil) var _ io.ReadWriteCloser = (*SerialPortDriver)(nil) -func TestBLESerialPort(t *testing.T) { +func TestNewSerialPortDriver(t *testing.T) { d := NewSerialPortDriver(testutil.NewBleTestAdaptor(), "123", "456") assert.Equal(t, "01:02:03:0A:0B:0C", d.Address()) } + +func TestNewSerialPortDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewSerialPortDriver(a, "123", "456", WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + +func TestSerialPortOpen(t *testing.T) { + const receiveCharacteristicUUID = "123" + tests := map[string]struct { + simConnectErr bool + simSubscribeErr bool + wantErr string + }{ + "open_ok": {}, + "error_connect": { + simConnectErr: true, + wantErr: "connect error", + }, + "error_subscribe": { + simSubscribeErr: true, + wantErr: "subscribe error", + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + // arrange + a := testutil.NewBleTestAdaptor() + a.SetSimulateConnectError(tc.simConnectErr) + a.SetSimulateSubscribeError(tc.simSubscribeErr) + d := NewSerialPortDriver(a, receiveCharacteristicUUID, "456") + // act + err := d.Open() + // assert + if tc.wantErr == "" { + require.NoError(t, err) + a.SendTestDataToSubscriber([]byte{3, 5, 7}) + assert.Equal(t, []byte{3, 5, 7}, d.responseData) + assert.Equal(t, receiveCharacteristicUUID, a.SubscribeCharaUUID()) + } else { + require.EqualError(t, err, tc.wantErr) + } + }) + } +} + +func TestSerialPortRead(t *testing.T) { + tests := map[string]struct { + availableData []byte + readDataBuffer []byte + wantCount int + wantData []byte + wantRemaining []byte + }{ + "no_data": { + availableData: []byte{}, + readDataBuffer: []byte{0, 0, 0}, + wantCount: 0, + wantData: []byte{0, 0, 0}, + wantRemaining: nil, + }, + "read_all": { + availableData: []byte{1, 2, 3}, + readDataBuffer: []byte{0, 0, 0}, + wantCount: 3, + wantData: []byte{1, 2, 3}, + wantRemaining: nil, + }, + "read_smaller": { + availableData: []byte{4, 6, 7}, + readDataBuffer: []byte{0, 0}, + wantCount: 2, + wantData: []byte{4, 6}, + wantRemaining: []byte{7}, + }, + "read_bigger": { + availableData: []byte{7, 8}, + readDataBuffer: []byte{0, 0, 0}, + wantCount: 2, + wantData: []byte{7, 8, 0}, + wantRemaining: nil, + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + // arrange + d := NewSerialPortDriver(testutil.NewBleTestAdaptor(), "123", "456") + d.responseData = append(d.responseData, tc.availableData...) + // act + gotCount, err := d.Read(tc.readDataBuffer) + // assert + require.NoError(t, err) + assert.Equal(t, tc.wantCount, gotCount) + assert.Equal(t, tc.wantData, tc.readDataBuffer) + assert.Equal(t, tc.wantRemaining, d.responseData) + }) + } +} + +func TestSerialPortWrite(t *testing.T) { + const transmitCharacteristicUUID = "456" + tests := map[string]struct { + writeData []byte + simError bool + wantCount int + wantData []byte + wantErr string + }{ + "write_ok": { + writeData: []byte{1, 2, 3}, + wantCount: 3, + wantData: []byte{1, 2, 3}, + }, + "error_write": { + writeData: []byte{1, 2, 3}, + simError: true, + wantCount: 3, + wantData: []byte{1, 2, 3}, + wantErr: "write error", + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + // arrange + a := testutil.NewBleTestAdaptor() + var gotUUID string + var gotData []byte + a.SetWriteCharacteristicTestFunc(func(cUUID string, data []byte) error { + gotUUID = cUUID + gotData = append(gotData, data...) + if tc.simError { + return fmt.Errorf("write error") + } + return nil + }) + d := NewSerialPortDriver(a, "123", transmitCharacteristicUUID) + + // act + gotCount, err := d.Write(tc.writeData) + // assert + if tc.wantErr == "" { + require.NoError(t, err) + } else { + require.EqualError(t, err, tc.wantErr) + } + assert.Equal(t, tc.wantCount, gotCount) + assert.Equal(t, transmitCharacteristicUUID, gotUUID) + assert.Equal(t, tc.wantData, gotData) + }) + } +} + +func TestSerialPortClose(t *testing.T) { + tests := map[string]struct { + simDisconnectErr bool + wantErr string + }{ + "close_ok": {}, + "error_close": { + simDisconnectErr: true, + wantErr: "disconnect error", + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + // arrange + a := testutil.NewBleTestAdaptor() + a.SetSimulateDisconnectError(tc.simDisconnectErr) + d := NewSerialPortDriver(a, "123", "456") + // act + err := d.Close() + // assert + if tc.wantErr == "" { + require.NoError(t, err) + } else { + require.EqualError(t, err, tc.wantErr) + } + }) + } +} diff --git a/drivers/ble/sphero/sphero_bb8_driver.go b/drivers/ble/sphero/sphero_bb8_driver.go index e1a459cbc..ee6f9088b 100644 --- a/drivers/ble/sphero/sphero_bb8_driver.go +++ b/drivers/ble/sphero/sphero_bb8_driver.go @@ -2,6 +2,7 @@ package sphero import ( "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/common/sphero" ) @@ -11,8 +12,8 @@ type BB8Driver struct { } // NewBB8Driver creates a driver for a Sphero BB-8 -func NewBB8Driver(a gobot.BLEConnector) *BB8Driver { - return &BB8Driver{OllieDriver: newOllieBaseDriver(a, "BB8", bb8DefaultCollisionConfig())} +func NewBB8Driver(a gobot.BLEConnector, opts ...ble.OptionApplier) *BB8Driver { + return &BB8Driver{OllieDriver: newOllieBaseDriver(a, "BB8", bb8DefaultCollisionConfig(), opts...)} } // bb8DefaultCollisionConfig returns a CollisionConfig with sensible collision defaults diff --git a/drivers/ble/sphero/sphero_bb8_driver_test.go b/drivers/ble/sphero/sphero_bb8_driver_test.go index 962239cc0..145c9c41e 100644 --- a/drivers/ble/sphero/sphero_bb8_driver_test.go +++ b/drivers/ble/sphero/sphero_bb8_driver_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/assert" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -19,3 +20,15 @@ func TestNewBB8Driver(t *testing.T) { assert.NotNil(t, d.OllieDriver) assert.Equal(t, d.defaultCollisionConfig, bb8DefaultCollisionConfig()) } + +func TestNewBB8DriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewBB8Driver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} diff --git a/drivers/ble/sphero/sphero_ollie_driver.go b/drivers/ble/sphero/sphero_ollie_driver.go index fffc4a008..81c2daf9b 100644 --- a/drivers/ble/sphero/sphero_ollie_driver.go +++ b/drivers/ble/sphero/sphero_ollie_driver.go @@ -74,17 +74,20 @@ type OllieDriver struct { } // NewOllieDriver creates a driver for a Sphero Ollie -func NewOllieDriver(a gobot.BLEConnector) *OllieDriver { - return newOllieBaseDriver(a, "Ollie", ollieDefaultCollisionConfig()) +func NewOllieDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *OllieDriver { + return newOllieBaseDriver(a, "Ollie", ollieDefaultCollisionConfig(), opts...) } -func newOllieBaseDriver(a gobot.BLEConnector, name string, dcc sphero.CollisionConfig) *OllieDriver { +func newOllieBaseDriver( + a gobot.BLEConnector, name string, + dcc sphero.CollisionConfig, opts ...ble.OptionApplier, +) *OllieDriver { d := &OllieDriver{ defaultCollisionConfig: dcc, Eventer: gobot.NewEventer(), packetChannel: make(chan *packet, 1024), } - d.Driver = ble.NewDriver(a, name, d.initialize, d.shutdown) + d.Driver = ble.NewDriver(a, name, d.initialize, d.shutdown, opts...) d.AddEvent(sphero.ErrorEvent) d.AddEvent(sphero.CollisionEvent) @@ -283,7 +286,7 @@ func (d *OllieDriver) shutdown() error { } // handleResponses handles responses returned from Ollie -func (d *OllieDriver) handleResponses(data []byte, e error) { +func (d *OllieDriver) handleResponses(data []byte) { // since packets can only be 20 bytes long, we have to puzzle them together newMessage := false diff --git a/drivers/ble/sphero/sphero_ollie_driver_test.go b/drivers/ble/sphero/sphero_ollie_driver_test.go index d4758c970..671cd1758 100644 --- a/drivers/ble/sphero/sphero_ollie_driver_test.go +++ b/drivers/ble/sphero/sphero_ollie_driver_test.go @@ -10,6 +10,7 @@ import ( "github.com/stretchr/testify/require" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" "gobot.io/x/gobot/v2/drivers/common/sphero" ) @@ -29,6 +30,18 @@ func TestNewOllieDriver(t *testing.T) { assert.NotNil(t, d.packetChannel) } +func TestNewOllieDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewOllieDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestOllieStartAndHalt(t *testing.T) { d := initTestOllieDriver() require.NoError(t, d.Start()) @@ -62,7 +75,7 @@ func TestLocatorData(t *testing.T) { d.GetLocatorData(func(p Point2D) { assert.Equal(t, point.y, p.Y) }) - d.handleResponses(packet, nil) + d.handleResponses(packet) } } @@ -100,11 +113,11 @@ func TestDataStreaming(t *testing.T) { c := uint16(b) bytes = append(bytes, byte(c)) } - d.handleResponses(bytes, nil) + d.handleResponses(bytes) } // send empty packet to indicate start of next message - d.handleResponses([]byte{0xFF}, nil) + d.handleResponses([]byte{0xFF}) select { case <-responseChan: case <-time.After(10 * time.Millisecond): diff --git a/drivers/ble/sphero/sphero_sprkplus_driver.go b/drivers/ble/sphero/sphero_sprkplus_driver.go index 744d571c9..75af9f310 100644 --- a/drivers/ble/sphero/sphero_sprkplus_driver.go +++ b/drivers/ble/sphero/sphero_sprkplus_driver.go @@ -2,6 +2,7 @@ package sphero import ( "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/common/sphero" ) @@ -11,8 +12,8 @@ type SPRKPlusDriver struct { } // NewSPRKPlusDriver creates a driver for a Sphero SPRK+ -func NewSPRKPlusDriver(a gobot.BLEConnector) *SPRKPlusDriver { - return &SPRKPlusDriver{OllieDriver: newOllieBaseDriver(a, "SPRKPlus", sprkplusDefaultCollisionConfig())} +func NewSPRKPlusDriver(a gobot.BLEConnector, opts ...ble.OptionApplier) *SPRKPlusDriver { + return &SPRKPlusDriver{OllieDriver: newOllieBaseDriver(a, "SPRKPlus", sprkplusDefaultCollisionConfig(), opts...)} } // sprkplusDefaultCollisionConfig returns a CollisionConfig with sensible collision defaults diff --git a/drivers/ble/sphero/sphero_sprkplus_driver_test.go b/drivers/ble/sphero/sphero_sprkplus_driver_test.go index 382c08ed0..ed74f2d85 100644 --- a/drivers/ble/sphero/sphero_sprkplus_driver_test.go +++ b/drivers/ble/sphero/sphero_sprkplus_driver_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/assert" "gobot.io/x/gobot/v2" + "gobot.io/x/gobot/v2/drivers/ble" "gobot.io/x/gobot/v2/drivers/ble/testutil" ) @@ -19,3 +20,15 @@ func TestNewSPRKPlusDriver(t *testing.T) { assert.NotNil(t, d.OllieDriver) assert.Equal(t, d.defaultCollisionConfig, sprkplusDefaultCollisionConfig()) } + +func TestNewSPRKPlusDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := testutil.NewBleTestAdaptor() + // act + d := NewSPRKPlusDriver(a, ble.WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} diff --git a/drivers/ble/testutil/testutil.go b/drivers/ble/testutil/testutil.go index 4724e5689..58f8e558e 100644 --- a/drivers/ble/testutil/testutil.go +++ b/drivers/ble/testutil/testutil.go @@ -1,6 +1,7 @@ package testutil import ( + "fmt" "sync" "gobot.io/x/gobot/v2" @@ -14,9 +15,13 @@ type bleTestClientAdaptor struct { mtx sync.Mutex withoutResponses bool + simulateConnectErr bool + simulateSubscribeErr bool + simulateDisconnectErr bool readCharacteristicFunc func(string) ([]byte, error) writeCharacteristicFunc func(string, []byte) error - subscribeFunc func([]byte, error) + subscribeFunc func([]byte) + subscribeCharaUUID string } func NewBleTestAdaptor() *bleTestClientAdaptor { @@ -31,6 +36,10 @@ func NewBleTestAdaptor() *bleTestClientAdaptor { } } +func (t *bleTestClientAdaptor) SubscribeCharaUUID() string { + return t.subscribeCharaUUID +} + func (t *bleTestClientAdaptor) SetReadCharacteristicTestFunc(f func(cUUID string) (data []byte, err error)) { t.mtx.Lock() defer t.mtx.Unlock() @@ -43,15 +52,40 @@ func (t *bleTestClientAdaptor) SetWriteCharacteristicTestFunc(f func(cUUID strin t.writeCharacteristicFunc = f } -func (t *bleTestClientAdaptor) SendTestDataToSubscriber(data []byte, err error) { +func (t *bleTestClientAdaptor) SetSimulateConnectError(val bool) { + t.simulateConnectErr = val +} + +func (t *bleTestClientAdaptor) SetSimulateSubscribeError(val bool) { + t.simulateSubscribeErr = val +} + +func (t *bleTestClientAdaptor) SetSimulateDisconnectError(val bool) { + t.simulateDisconnectErr = val +} + +func (t *bleTestClientAdaptor) SendTestDataToSubscriber(data []byte) { t.mtx.Lock() defer t.mtx.Unlock() - t.subscribeFunc(data, err) + t.subscribeFunc(data) +} + +func (t *bleTestClientAdaptor) Connect() error { + if t.simulateConnectErr { + return fmt.Errorf("connect error") + } + return nil +} + +func (t *bleTestClientAdaptor) Reconnect() error { return nil } + +func (t *bleTestClientAdaptor) Disconnect() error { + if t.simulateDisconnectErr { + return fmt.Errorf("disconnect error") + } + return nil } -func (t *bleTestClientAdaptor) Connect() error { return nil } -func (t *bleTestClientAdaptor) Reconnect() error { return nil } -func (t *bleTestClientAdaptor) Disconnect() error { return nil } func (t *bleTestClientAdaptor) Finalize() error { return nil } func (t *bleTestClientAdaptor) Name() string { return t.name } func (t *bleTestClientAdaptor) SetName(n string) { t.name = n } @@ -70,7 +104,11 @@ func (t *bleTestClientAdaptor) WriteCharacteristic(cUUID string, data []byte) er return t.writeCharacteristicFunc(cUUID, data) } -func (t *bleTestClientAdaptor) Subscribe(cUUID string, f func([]byte, error)) error { +func (t *bleTestClientAdaptor) Subscribe(cUUID string, f func(data []byte)) error { + if t.simulateSubscribeErr { + return fmt.Errorf("subscribe error") + } + t.subscribeCharaUUID = cUUID t.subscribeFunc = f return nil } diff --git a/drivers/serial/serial_driver.go b/drivers/serial/serial_driver.go index 9b1aaf724..32e8ec7e7 100644 --- a/drivers/serial/serial_driver.go +++ b/drivers/serial/serial_driver.go @@ -39,7 +39,7 @@ type driver struct { } // newDriver creates a new basic serial gobot driver. -func newDriver(a interface{}, name string) *driver { +func newDriver(a interface{}, name string, opts ...optionApplier) *driver { d := driver{ Commander: gobot.NewCommander(), connection: a, @@ -49,6 +49,10 @@ func newDriver(a interface{}, name string) *driver { mutex: &sync.Mutex{}, } + for _, o := range opts { + o.apply(d.driverCfg) + } + return &d } @@ -63,7 +67,7 @@ func (d *driver) Name() string { } // SetName sets the name of the driver. -// Deprecated: Please use option [aio.WithName] instead. +// Deprecated: Please use option [serial.WithName] instead. func (d *driver) SetName(name string) { WithName(name).apply(d.driverCfg) } diff --git a/drivers/serial/serial_driver_test.go b/drivers/serial/serial_driver_test.go index b2dda80c6..7e965b609 100644 --- a/drivers/serial/serial_driver_test.go +++ b/drivers/serial/serial_driver_test.go @@ -36,6 +36,21 @@ func Test_newDriver(t *testing.T) { assert.NotNil(t, d.mutex) } +func Test_newDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const ( + name = "mybot" + newName = "overwrite mybot" + ) + a := newSerialTestAdaptor() + // act + d := newDriver(a, name, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func Test_applyWithName(t *testing.T) { // arrange const name = "mybot" diff --git a/drivers/serial/sphero_driver.go b/drivers/serial/sphero_driver.go index b65c52f7b..6bdd969f5 100644 --- a/drivers/serial/sphero_driver.go +++ b/drivers/serial/sphero_driver.go @@ -51,9 +51,9 @@ type SpheroDriver struct { // "SetStabilization" - See SpheroDriver.SetStabilization // "SetDataStreaming" - See SpheroDriver.SetDataStreaming // "SetRotationRate" - See SpheroDriver.SetRotationRate -func NewSpheroDriver(a spheroSerialAdaptor) *SpheroDriver { +func NewSpheroDriver(a spheroSerialAdaptor, opts ...optionApplier) *SpheroDriver { d := &SpheroDriver{ - driver: newDriver(a, "Sphero"), + driver: newDriver(a, "Sphero", opts...), Eventer: gobot.NewEventer(), packetChannel: make(chan *packet, 1024), responseChannel: make(chan []uint8, 1024), diff --git a/drivers/serial/sphero_driver_test.go b/drivers/serial/sphero_driver_test.go index 417f474d0..55f57d23c 100644 --- a/drivers/serial/sphero_driver_test.go +++ b/drivers/serial/sphero_driver_test.go @@ -27,6 +27,18 @@ func TestNewSpheroDriver(t *testing.T) { assert.NotNil(t, d.Eventer) } +func TestNewSpheroDriverWithName(t *testing.T) { + // This is a general test, that options are applied in constructor by using the common WithName() option. Further + // tests for options can also be done by call of "WithOption(val).apply(cfg)". + // arrange + const newName = "new name" + a := newSerialTestAdaptor() + // act + d := NewSpheroDriver(a, WithName(newName)) + // assert + assert.Equal(t, newName, d.Name()) +} + func TestSpheroCommands(t *testing.T) { d := initTestSpheroDriver() var ret interface{} diff --git a/examples/ble_battery.go b/examples/ble_battery.go index 4656954fa..22276b2b6 100644 --- a/examples/ble_battery.go +++ b/examples/ble_battery.go @@ -31,7 +31,11 @@ func main() { work := func() { gobot.Every(5*time.Second, func() { - fmt.Println("Battery level:", battery.GetBatteryLevel()) + level, err := battery.GetBatteryLevel() + if err != nil { + fmt.Println(err) + } + fmt.Println("Battery level:", level) }) } diff --git a/examples/ble_device_info.go b/examples/ble_device_info.go index bff64e7e9..e463a8ccb 100644 --- a/examples/ble_device_info.go +++ b/examples/ble_device_info.go @@ -29,11 +29,35 @@ func main() { info := ble.NewDeviceInformationDriver(bleAdaptor) work := func() { - fmt.Println("Model number:", info.GetModelNumber()) - fmt.Println("Firmware rev:", info.GetFirmwareRevision()) - fmt.Println("Hardware rev:", info.GetHardwareRevision()) - fmt.Println("Manufacturer name:", info.GetManufacturerName()) - fmt.Println("PnPId:", info.GetPnPId()) + modelNo, err := info.GetModelNumber() + if err != nil { + fmt.Println(err) + } + fmt.Println("Model number:", modelNo) + + fwRev, err := info.GetFirmwareRevision() + if err != nil { + fmt.Println(err) + } + fmt.Println("Firmware rev:", fwRev) + + hwRev, err := info.GetHardwareRevision() + if err != nil { + fmt.Println(err) + } + fmt.Println("Hardware rev:", hwRev) + + manuName, err := info.GetManufacturerName() + if err != nil { + fmt.Println(err) + } + fmt.Println("Manufacturer name:", manuName) + + pid, err := info.GetPnPId() + if err != nil { + fmt.Println(err) + } + fmt.Println("PnPId:", pid) } robot := gobot.NewRobot("bleBot", diff --git a/examples/ble_generic_access.go b/examples/ble_generic_access.go index 416571206..aa77064a6 100644 --- a/examples/ble_generic_access.go +++ b/examples/ble_generic_access.go @@ -29,8 +29,17 @@ func main() { access := ble.NewGenericAccessDriver(bleAdaptor) work := func() { - fmt.Println("Device name:", access.GetDeviceName()) - fmt.Println("Appearance:", access.GetAppearance()) + devName, err := access.GetDeviceName() + if err != nil { + fmt.Println(err) + } + fmt.Println("Device name:", devName) + + appearance, err := access.GetAppearance() + if err != nil { + fmt.Println(err) + } + fmt.Println("Appearance:", appearance) } robot := gobot.NewRobot("bleBot", diff --git a/examples/ble_multiple_generic.go b/examples/ble_multiple_generic.go index bbce13d9e..ddc7d313f 100644 --- a/examples/ble_multiple_generic.go +++ b/examples/ble_multiple_generic.go @@ -30,8 +30,17 @@ func NewSwarmBot(port string) *gobot.Robot { access := ble.NewGenericAccessDriver(bleAdaptor) work := func() { - fmt.Println("Device name:", access.GetDeviceName()) - fmt.Println("Appearance:", access.GetAppearance()) + devName, err := access.GetDeviceName() + if err != nil { + fmt.Println(err) + } + fmt.Println("Device name:", devName) + + appearance, err := access.GetAppearance() + if err != nil { + fmt.Println(err) + } + fmt.Println("Appearance:", appearance) } robot := gobot.NewRobot("bot "+port, diff --git a/examples/ble_multiple_info.go b/examples/ble_multiple_info.go index 6155138b3..b4960e9a5 100644 --- a/examples/ble_multiple_info.go +++ b/examples/ble_multiple_info.go @@ -30,11 +30,35 @@ func NewSwarmBot(port string) *gobot.Robot { info := ble.NewDeviceInformationDriver(bleAdaptor) work := func() { - fmt.Println("Model number:", info.GetModelNumber()) - fmt.Println("Firmware rev:", info.GetFirmwareRevision()) - fmt.Println("Hardware rev:", info.GetHardwareRevision()) - fmt.Println("Manufacturer name:", info.GetManufacturerName()) - fmt.Println("PnPId:", info.GetPnPId()) + modelNo, err := info.GetModelNumber() + if err != nil { + fmt.Println(err) + } + fmt.Println("Model number:", modelNo) + + fwRev, err := info.GetFirmwareRevision() + if err != nil { + fmt.Println(err) + } + fmt.Println("Firmware rev:", fwRev) + + hwRev, err := info.GetHardwareRevision() + if err != nil { + fmt.Println(err) + } + fmt.Println("Hardware rev:", hwRev) + + manuName, err := info.GetManufacturerName() + if err != nil { + fmt.Println(err) + } + fmt.Println("Manufacturer name:", manuName) + + pid, err := info.GetPnPId() + if err != nil { + fmt.Println(err) + } + fmt.Println("PnPId:", pid) } robot := gobot.NewRobot("bot "+port, diff --git a/examples/serial_sphero_conways.go b/examples/serial_sphero_conways.go index 5113ab5a0..c03a0b2df 100644 --- a/examples/serial_sphero_conways.go +++ b/examples/serial_sphero_conways.go @@ -35,8 +35,7 @@ func main() { for _, port := range spheros { spheroAdaptor := serialport.NewAdaptor(port) - cell := serial.NewSpheroDriver(spheroAdaptor) - cell.SetName("Sphero" + port) + cell := serial.NewSpheroDriver(spheroAdaptor, serial.WithName("Sphero"+port)) work := func() { conway := new(conway) diff --git a/examples/serial_sphero_multiple.go b/examples/serial_sphero_multiple.go index c728ce9ff..a5ab95b02 100644 --- a/examples/serial_sphero_multiple.go +++ b/examples/serial_sphero_multiple.go @@ -19,8 +19,7 @@ import ( func NewSwarmBot(port string) *gobot.Robot { spheroAdaptor := serialport.NewAdaptor(port) - spheroDriver := serial.NewSpheroDriver(spheroAdaptor) - spheroDriver.SetName("Sphero" + port) + spheroDriver := serial.NewSpheroDriver(spheroAdaptor, serial.WithName("Sphero"+port)) work := func() { spheroDriver.Stop() diff --git a/platforms/bleclient/README.md b/platforms/bleclient/README.md index c243cf7a7..271c93880 100644 --- a/platforms/bleclient/README.md +++ b/platforms/bleclient/README.md @@ -71,7 +71,11 @@ func main() { work := func() { gobot.Every(5*time.Second, func() { - fmt.Println("Battery level:", battery.GetBatteryLevel()) + level, err := battery.GetBatteryLevel() + if err != nil { + fmt.Println(err) + } + fmt.Println("Battery level:", level) }) } diff --git a/platforms/bleclient/ble_client_adaptor.go b/platforms/bleclient/ble_client_adaptor.go index f73605930..ffc09f155 100644 --- a/platforms/bleclient/ble_client_adaptor.go +++ b/platforms/bleclient/ble_client_adaptor.go @@ -181,7 +181,7 @@ func (a *Adaptor) WriteCharacteristic(cUUID string, data []byte) error { // Subscribe subscribes to notifications from the BLE device for the // requested service and characteristic -func (a *Adaptor) Subscribe(cUUID string, f func([]byte, error)) error { +func (a *Adaptor) Subscribe(cUUID string, f func([]byte)) error { if !a.connected { return fmt.Errorf("Cannot subscribe to BLE device until connected") } @@ -189,10 +189,7 @@ func (a *Adaptor) Subscribe(cUUID string, f func([]byte, error)) error { cUUID = convertUUID(cUUID) if char, ok := a.characteristics[cUUID]; ok { - fn := func(d []byte) { - f(d, nil) - } - return char.EnableNotifications(fn) + return char.EnableNotifications(f) } return fmt.Errorf("Unknown characteristic: %s", cUUID) diff --git a/platforms/serialport/adaptor_test.go b/platforms/serialport/adaptor_test.go index 65d7a4486..dd5321e8e 100644 --- a/platforms/serialport/adaptor_test.go +++ b/platforms/serialport/adaptor_test.go @@ -46,7 +46,7 @@ func NewNullReadWriteCloser() *nullReadWriteCloser { } } -func initTestSpheroAdaptor() (*Adaptor, *nullReadWriteCloser) { +func initTestAdaptor() (*Adaptor, *nullReadWriteCloser) { a := NewAdaptor("/dev/null") rwc := NewNullReadWriteCloser() @@ -56,34 +56,34 @@ func initTestSpheroAdaptor() (*Adaptor, *nullReadWriteCloser) { return a, rwc } -func TestSpheroAdaptorName(t *testing.T) { - a, _ := initTestSpheroAdaptor() +func TestNewAdaptor(t *testing.T) { + a := NewAdaptor("/dev/null") assert.True(t, strings.HasPrefix(a.Name(), "Serial")) - a.SetName("NewName") - assert.Equal(t, "NewName", a.Name()) + assert.Equal(t, "/dev/null", a.Port()) } -func TestSpheroAdaptor(t *testing.T) { - a, _ := initTestSpheroAdaptor() +func TestName(t *testing.T) { + a, _ := initTestAdaptor() assert.True(t, strings.HasPrefix(a.Name(), "Serial")) - assert.Equal(t, "/dev/null", a.Port()) + a.SetName("NewName") + assert.Equal(t, "NewName", a.Name()) } -func TestSpheroAdaptorReconnect(t *testing.T) { - a, _ := initTestSpheroAdaptor() - _ = a.Connect() +func TestReconnect(t *testing.T) { + a, _ := initTestAdaptor() + require.NoError(t, a.Connect()) assert.True(t, a.connected) - _ = a.Reconnect() + require.NoError(t, a.Reconnect()) assert.True(t, a.connected) - _ = a.Disconnect() + require.NoError(t, a.Disconnect()) assert.False(t, a.connected) - _ = a.Reconnect() + require.NoError(t, a.Reconnect()) assert.True(t, a.connected) } -func TestSpheroAdaptorFinalize(t *testing.T) { - a, rwc := initTestSpheroAdaptor() - _ = a.Connect() +func TestFinalize(t *testing.T) { + a, rwc := initTestAdaptor() + require.NoError(t, a.Connect()) require.NoError(t, a.Finalize()) rwc.testAdaptorClose = func() error { @@ -94,8 +94,8 @@ func TestSpheroAdaptorFinalize(t *testing.T) { require.ErrorContains(t, a.Finalize(), "close error") } -func TestSpheroAdaptorConnect(t *testing.T) { - a, _ := initTestSpheroAdaptor() +func TestConnect(t *testing.T) { + a, _ := initTestAdaptor() require.NoError(t, a.Connect()) a.connect = func(string) (io.ReadWriteCloser, error) {