test(all): substitude assert.Error by assert.ErrorContains (#1014)

hybridgroup · Oct 25, 2023 · f9950e2 · f9950e2
1 parent ee4368b
commit f9950e2
Show file tree

Hide file tree

Showing 80 changed files with 274 additions and 274 deletions.
diff --git a/drivers/gpio/buzzer_driver_test.go b/drivers/gpio/buzzer_driver_test.go
@@ -57,7 +57,7 @@ func TestBuzzerDriverOnError(t *testing.T) {
 		return errors.New("write error")
 	})
 
-	assert.Error(t, d.On(), "write error")
+	assert.ErrorContains(t, d.On(), "write error")
 }
 
 func TestBuzzerDriverOffError(t *testing.T) {
@@ -67,7 +67,7 @@ func TestBuzzerDriverOffError(t *testing.T) {
 		return errors.New("write error")
 	})
 
-	assert.Error(t, d.Off(), "write error")
+	assert.ErrorContains(t, d.Off(), "write error")
 }
 
 func TestBuzzerDriverToneError(t *testing.T) {
@@ -77,5 +77,5 @@ func TestBuzzerDriverToneError(t *testing.T) {
 		return errors.New("write error")
 	})
 
-	assert.Error(t, d.Tone(100, 0.01), "write error")
+	assert.ErrorContains(t, d.Tone(100, 0.01), "write error")
 }
diff --git a/drivers/gpio/direct_pin_driver_test.go b/drivers/gpio/direct_pin_driver_test.go
@@ -43,13 +43,13 @@ func TestDirectPinDriver(t *testing.T) {
 	assert.Nil(t, ret["err"])
 
 	err = d.Command("DigitalWrite")(map[string]interface{}{"level": "1"})
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 
 	err = d.Command("PwmWrite")(map[string]interface{}{"level": "1"})
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 
 	err = d.Command("ServoWrite")(map[string]interface{}{"level": "1"})
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 }
 
 func TestDirectPinDriverStart(t *testing.T) {
@@ -74,7 +74,7 @@ func TestDirectPinDriverOff(t *testing.T) {
 func TestDirectPinDriverOffNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
-	assert.Error(t, d.Off(), "DigitalWrite is not supported by this platform")
+	assert.ErrorContains(t, d.Off(), "DigitalWrite is not supported by this platform")
 }
 
 func TestDirectPinDriverOn(t *testing.T) {
@@ -91,7 +91,7 @@ func TestDirectPinDriverOnError(t *testing.T) {
 func TestDirectPinDriverOnNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
-	assert.Error(t, d.On(), "DigitalWrite is not supported by this platform")
+	assert.ErrorContains(t, d.On(), "DigitalWrite is not supported by this platform")
 }
 
 func TestDirectPinDriverDigitalWrite(t *testing.T) {
@@ -103,7 +103,7 @@ func TestDirectPinDriverDigitalWrite(t *testing.T) {
 func TestDirectPinDriverDigitalWriteNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
-	assert.Error(t, d.DigitalWrite(1), "DigitalWrite is not supported by this platform")
+	assert.ErrorContains(t, d.DigitalWrite(1), "DigitalWrite is not supported by this platform")
 }
 
 func TestDirectPinDriverDigitalWriteError(t *testing.T) {
@@ -122,7 +122,7 @@ func TestDirectPinDriverDigitalReadNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
 	_, e := d.DigitalRead()
-	assert.Error(t, e, "DigitalRead is not supported by this platform")
+	assert.ErrorContains(t, e, "DigitalRead is not supported by this platform")
 }
 
 func TestDirectPinDriverPwmWrite(t *testing.T) {
@@ -134,7 +134,7 @@ func TestDirectPinDriverPwmWrite(t *testing.T) {
 func TestDirectPinDriverPwmWriteNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
-	assert.Error(t, d.PwmWrite(1), "PwmWrite is not supported by this platform")
+	assert.ErrorContains(t, d.PwmWrite(1), "PwmWrite is not supported by this platform")
 }
 
 func TestDirectPinDriverPwmWriteError(t *testing.T) {
@@ -151,7 +151,7 @@ func TestDirectPinDriverServoWrite(t *testing.T) {
 func TestDirectPinDriverServoWriteNotSupported(t *testing.T) {
 	a := &gpioTestBareAdaptor{}
 	d := NewDirectPinDriver(a, "1")
-	assert.Error(t, d.ServoWrite(1), "ServoWrite is not supported by this platform")
+	assert.ErrorContains(t, d.ServoWrite(1), "ServoWrite is not supported by this platform")
 }
 
 func TestDirectPinDriverServoWriteError(t *testing.T) {

diff --git a/drivers/gpio/hd44780_driver_test.go b/drivers/gpio/hd44780_driver_test.go
@@ -93,7 +93,7 @@ func TestHD44780DriverStartError(t *testing.T) {
 		D7: "",
 	}
 	d = NewHD44780Driver(a, 2, 16, HD44780_4BITMODE, "13", "15", pins)
-	assert.Error(t, d.Start(), "Initialization error")
+	assert.ErrorContains(t, d.Start(), "Initialization error")
 
 	pins = HD44780DataPin{
 		D0: "31",
@@ -106,7 +106,7 @@ func TestHD44780DriverStartError(t *testing.T) {
 		D7: "",
 	}
 	d = NewHD44780Driver(a, 2, 16, HD44780_8BITMODE, "13", "15", pins)
-	assert.Error(t, d.Start(), "Initialization error")
+	assert.ErrorContains(t, d.Start(), "Initialization error")
 }
 
 func TestHD44780DriverWrite(t *testing.T) {
@@ -130,14 +130,14 @@ func TestHD44780DriverWriteError(t *testing.T) {
 		return errors.New("write error")
 	}
 	_ = d.Start()
-	assert.Error(t, d.Write("hello gobot"), "write error")
+	assert.ErrorContains(t, d.Write("hello gobot"), "write error")
 
 	d, a = initTestHD44780Driver8BitModeWithStubbedAdaptor()
 	a.testAdaptorDigitalWrite = func(string, byte) (err error) {
 		return errors.New("write error")
 	}
 	_ = d.Start()
-	assert.Error(t, d.Write("hello gobot"), "write error")
+	assert.ErrorContains(t, d.Write("hello gobot"), "write error")
 }
 
 func TestHD44780DriverClear(t *testing.T) {
@@ -158,10 +158,10 @@ func TestHD44780DriverSetCursor(t *testing.T) {
 func TestHD44780DriverSetCursorInvalid(t *testing.T) {
 	d := initTestHD44780Driver()
 
-	assert.Error(t, d.SetCursor(-1, 3), "Invalid position value (-1, 3), range (1, 15)")
-	assert.Error(t, d.SetCursor(2, 3), "Invalid position value (2, 3), range (1, 15)")
-	assert.Error(t, d.SetCursor(0, -1), "Invalid position value (0, -1), range (1, 15)")
-	assert.Error(t, d.SetCursor(0, 16), "Invalid position value (0, 16), range (1, 15)")
+	assert.ErrorContains(t, d.SetCursor(-1, 3), "Invalid position value (-1, 3), range (1, 15)")
+	assert.ErrorContains(t, d.SetCursor(2, 3), "Invalid position value (2, 3), range (1, 15)")
+	assert.ErrorContains(t, d.SetCursor(0, -1), "Invalid position value (0, -1), range (1, 15)")
+	assert.ErrorContains(t, d.SetCursor(0, 16), "Invalid position value (0, 16), range (1, 15)")
 }
 
 func TestHD44780DriverDisplayOn(t *testing.T) {
@@ -233,5 +233,5 @@ func TestHD44780DriverCreateChar(t *testing.T) {
 func TestHD44780DriverCreateCharError(t *testing.T) {
 	d := initTestHD44780Driver()
 	charMap := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
-	assert.Error(t, d.CreateChar(8, charMap), "can't set a custom character at a position greater than 7")
+	assert.ErrorContains(t, d.CreateChar(8, charMap), "can't set a custom character at a position greater than 7")
 }
diff --git a/drivers/gpio/led_driver_test.go b/drivers/gpio/led_driver_test.go
@@ -38,16 +38,16 @@ func TestLedDriver(t *testing.T) {
 	}
 
 	err = d.Command("Toggle")(nil)
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 
 	err = d.Command("On")(nil)
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 
 	err = d.Command("Off")(nil)
-	assert.Error(t, err.(error), "write error")
+	assert.ErrorContains(t, err.(error), "write error")
 
 	err = d.Command("Brightness")(map[string]interface{}{"level": 100.0})
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 }
 
 func TestLedDriverStart(t *testing.T) {
@@ -76,7 +76,7 @@ func TestLedDriverBrightness(t *testing.T) {
 		err = errors.New("pwm error")
 		return
 	}
-	assert.Error(t, d.Brightness(150), "pwm error")
+	assert.ErrorContains(t, d.Brightness(150), "pwm error")
 }
 
 func TestLEDDriverDefaultName(t *testing.T) {

diff --git a/drivers/gpio/rgb_led_driver_test.go b/drivers/gpio/rgb_led_driver_test.go
@@ -42,16 +42,16 @@ func TestRgbLedDriver(t *testing.T) {
 	}
 
 	err = d.Command("Toggle")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("On")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("Off")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("SetRGB")(map[string]interface{}{"r": 0xff, "g": 0xff, "b": 0xff})
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 }
 
 func TestRgbLedDriverStart(t *testing.T) {
@@ -83,7 +83,7 @@ func TestRgbLedDriverSetLevel(t *testing.T) {
 		err = errors.New("pwm error")
 		return
 	}
-	assert.Error(t, d.SetLevel("1", 150), "pwm error")
+	assert.ErrorContains(t, d.SetLevel("1", 150), "pwm error")
 }
 
 func TestRgbLedDriverDefaultName(t *testing.T) {

diff --git a/drivers/gpio/servo_driver_test.go b/drivers/gpio/servo_driver_test.go
@@ -29,16 +29,16 @@ func TestServoDriver(t *testing.T) {
 	}
 
 	err = d.Command("Min")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("Center")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("Max")(nil)
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 
 	err = d.Command("Move")(map[string]interface{}{"angle": 100.0})
-	assert.Error(t, err.(error), "pwm error")
+	assert.ErrorContains(t, err.(error), "pwm error")
 }
 
 func TestServoDriverStart(t *testing.T) {

diff --git a/drivers/gpio/stepper_driver_test.go b/drivers/gpio/stepper_driver_test.go
@@ -57,7 +57,7 @@ func TestStepperDriverDefaultDirection(t *testing.T) {
 func TestStepperDriverInvalidDirection(t *testing.T) {
 	d := initStepperMotorDriver()
 	err := d.SetDirection("reverse")
-	assert.Error(t, err, "Invalid direction. Value should be forward or backward")
+	assert.ErrorContains(t, err, "Invalid direction. Value should be forward or backward")
 }
 
 func TestStepperDriverMoveForward(t *testing.T) {

diff --git a/drivers/i2c/adafruit1109_driver_test.go b/drivers/i2c/adafruit1109_driver_test.go
@@ -73,15 +73,15 @@ func TestAdafruit1109StartWriteErr(t *testing.T) {
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {
 		return 0, errors.New("write error")
 	}
-	assert.Error(t, d.Start(), "write error")
+	assert.ErrorContains(t, d.Start(), "write error")
 }
 
 func TestAdafruit1109StartReadErr(t *testing.T) {
 	d, adaptor := initTestAdafruit1109WithStubbedAdaptor()
 	adaptor.i2cReadImpl = func([]byte) (int, error) {
 		return 0, errors.New("read error")
 	}
-	assert.Error(t, d.Start(), "MCP write-read: MCP write-ReadByteData(reg=0): read error")
+	assert.ErrorContains(t, d.Start(), "MCP write-read: MCP write-ReadByteData(reg=0): read error")
 }
 
 func TestAdafruit1109Halt(t *testing.T) {

diff --git a/drivers/i2c/adafruit_driver_test.go b/drivers/i2c/adafruit_driver_test.go
@@ -45,21 +45,21 @@ func TestAdafruitMotorHatDriverStartWriteError(t *testing.T) {
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {
 		return 0, errors.New("write error")
 	}
-	assert.Error(t, d.Start(), "write error")
+	assert.ErrorContains(t, d.Start(), "write error")
 }
 
 func TestAdafruitMotorHatDriverStartReadError(t *testing.T) {
 	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
 	adaptor.i2cReadImpl = func([]byte) (int, error) {
 		return 0, errors.New("read error")
 	}
-	assert.Error(t, d.Start(), "read error")
+	assert.ErrorContains(t, d.Start(), "read error")
 }
 
 func TestAdafruitMotorHatDriverStartConnectError(t *testing.T) {
 	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
 	adaptor.Testi2cConnectErr(true)
-	assert.Error(t, d.Start(), "Invalid i2c connection")
+	assert.ErrorContains(t, d.Start(), "Invalid i2c connection")
 }
 
 func TestAdafruitMotorHatDriverHalt(t *testing.T) {
@@ -96,7 +96,7 @@ func TestAdafruitMotorHatDriverSetServoMotorFreqError(t *testing.T) {
 	}
 
 	freq := 60.0
-	assert.Error(t, ada.SetServoMotorFreq(freq), "write error")
+	assert.ErrorContains(t, ada.SetServoMotorFreq(freq), "write error")
 }
 
 func TestAdafruitMotorHatDriverSetServoMotorPulse(t *testing.T) {
@@ -122,7 +122,7 @@ func TestAdafruitMotorHatDriverSetServoMotorPulseError(t *testing.T) {
 	var channel byte = 7
 	var on int32 = 1234
 	var off int32 = 4321
-	assert.Error(t, ada.SetServoMotorPulse(channel, on, off), "write error")
+	assert.ErrorContains(t, ada.SetServoMotorPulse(channel, on, off), "write error")
 }
 
 func TestAdafruitMotorHatDriverSetDCMotorSpeed(t *testing.T) {
@@ -144,7 +144,7 @@ func TestAdafruitMotorHatDriverSetDCMotorSpeedError(t *testing.T) {
 		return 0, errors.New("write error")
 	}
 
-	assert.Error(t, ada.SetDCMotorSpeed(1, 255), "write error")
+	assert.ErrorContains(t, ada.SetDCMotorSpeed(1, 255), "write error")
 }
 
 func TestAdafruitMotorHatDriverRunDCMotor(t *testing.T) {
@@ -166,9 +166,9 @@ func TestAdafruitMotorHatDriverRunDCMotorError(t *testing.T) {
 	}
 
 	dcMotor := 1
-	assert.Error(t, ada.RunDCMotor(dcMotor, AdafruitForward), "write error")
-	assert.Error(t, ada.RunDCMotor(dcMotor, AdafruitBackward), "write error")
-	assert.Error(t, ada.RunDCMotor(dcMotor, AdafruitRelease), "write error")
+	assert.ErrorContains(t, ada.RunDCMotor(dcMotor, AdafruitForward), "write error")
+	assert.ErrorContains(t, ada.RunDCMotor(dcMotor, AdafruitBackward), "write error")
+	assert.ErrorContains(t, ada.RunDCMotor(dcMotor, AdafruitRelease), "write error")
 }
 
 func TestAdafruitMotorHatDriverSetStepperMotorSpeed(t *testing.T) {

diff --git a/drivers/i2c/ads1x15_driver_1015_test.go b/drivers/i2c/ads1x15_driver_1015_test.go
@@ -115,14 +115,14 @@ func TestADS1x15AnalogReadError(t *testing.T) {
 	}
 
 	_, err := d.AnalogRead("0")
-	assert.Error(t, err, "read error")
+	assert.ErrorContains(t, err, "read error")
 }
 
 func TestADS1x15AnalogReadInvalidPin(t *testing.T) {
 	d, _ := initTestADS1015DriverWithStubbedAdaptor()
 
 	_, err := d.AnalogRead("99")
-	assert.Error(t, err, "Invalid channel (99), must be between 0 and 3")
+	assert.ErrorContains(t, err, "Invalid channel (99), must be between 0 and 3")
 }
 
 func TestADS1x15AnalogReadWriteError(t *testing.T) {
@@ -133,41 +133,41 @@ func TestADS1x15AnalogReadWriteError(t *testing.T) {
 	}
 
 	_, err := d.AnalogRead("0")
-	assert.Error(t, err, "write error")
+	assert.ErrorContains(t, err, "write error")
 
 	_, err = d.AnalogRead("0-1")
-	assert.Error(t, err, "write error")
+	assert.ErrorContains(t, err, "write error")
 
 	_, err = d.AnalogRead("2-3")
-	assert.Error(t, err, "write error")
+	assert.ErrorContains(t, err, "write error")
 }
 
 func TestADS1x15ReadInvalidChannel(t *testing.T) {
 	d, _ := initTestADS1015DriverWithStubbedAdaptor()
 
 	_, err := d.Read(9, 1, 1600)
-	assert.Error(t, err, "Invalid channel (9), must be between 0 and 3")
+	assert.ErrorContains(t, err, "Invalid channel (9), must be between 0 and 3")
 }
 
 func TestADS1x15ReadInvalidGain(t *testing.T) {
 	d, _ := initTestADS1015DriverWithStubbedAdaptor()
 
 	_, err := d.Read(0, 8, 1600)
-	assert.Error(t, err, "Gain (8) must be one of: [0 1 2 3 4 5 6 7]")
+	assert.ErrorContains(t, err, "Gain (8) must be one of: [0 1 2 3 4 5 6 7]")
 }
 
 func TestADS1x15ReadInvalidDataRate(t *testing.T) {
 	d, _ := initTestADS1015DriverWithStubbedAdaptor()
 
 	_, err := d.Read(0, 1, 321)
-	assert.Error(t, err, "Invalid data rate (321). Accepted values: [128 250 490 920 1600 2400 3300]")
+	assert.ErrorContains(t, err, "Invalid data rate (321). Accepted values: [128 250 490 920 1600 2400 3300]")
 }
 
 func TestADS1x15ReadDifferenceInvalidChannel(t *testing.T) {
 	d, _ := initTestADS1015DriverWithStubbedAdaptor()
 
 	_, err := d.ReadDifference(9, 1, 1600)
-	assert.Error(t, err, "Invalid channel (9), must be between 0 and 3")
+	assert.ErrorContains(t, err, "Invalid channel (9), must be between 0 and 3")
 }
 
 func TestADS1015_rawRead(t *testing.T) {