refactor: hrp code

hrp/code/code.go

@@ -53,28 +53,20 @@ var (
 
 // summary: [40, 50)
 var (
-	GenSummaryFailed = errors.New("gen summary failed") // 40
+	GenSummaryFailed = errors.New("generate summary failed") // 40
-	DownloadFailed   = errors.New("download failed")    // 48
+	DownloadFailed   = errors.New("download failed")         // 48
-	UploadFailed     = errors.New("upload failed")      // 49
+	UploadFailed     = errors.New("upload failed")           // 49
 )
 
-// ios device related: [50, 60)
+// device related: [50, 70)
 var (
-	IOSDeviceConnectionError = errors.New("ios device connection error")  // 50
+	DeviceConnectionError = errors.New("device general connection error") // 50
-	IOSDeviceHTTPDriverError = errors.New("ios device HTTP driver error") // 51
+	DeviceHTTPDriverError = errors.New("device HTTP driver error")        // 51
-	IOSDeviceUSBDriverError  = errors.New("ios device USB driver error")  // 52
+	DeviceUSBDriverError  = errors.New("device USB driver error")         // 52
-	IOSScreenShotError       = errors.New("ios screenshot error")         // 55
+	DeviceShellExecError  = errors.New("device shell exec error")         // 62
-	IOSCaptureLogError       = errors.New("ios capture log error")        // 56
+	DeviceOfflineError    = errors.New("device offline")                  // 63
-)
+	DeviceScreenShotError = errors.New("device screenshot error")         // 65
-
+	DeviceCaptureLogError = errors.New("device capture log error")        // 66
-// android device related: [60, 70)
-var (
-	AndroidDeviceConnectionError        = errors.New("android device general connection error") // 60
-	AndroidDeviceConnectionRefusedError = errors.New("android device connection refused")       // 61
-	AndroidShellExecError               = errors.New("android adb shell exec error")            // 62
-	AndroidDeviceOfflineError           = errors.New("android device offline")                  // 63
-	AndroidScreenShotError              = errors.New("android screenshot error")                // 65
-	AndroidCaptureLogError              = errors.New("android capture log error")               // 66
 )
 
 // UI automation related: [70, 80)
@@ -147,20 +139,14 @@ var errorsMap = map[error]int{
 	DownloadFailed:   48,
 	UploadFailed:     49,
 
-	// ios related
+	// device related
-	IOSDeviceConnectionError: 50,
+	DeviceConnectionError: 50,
-	IOSDeviceHTTPDriverError: 51,
+	DeviceHTTPDriverError: 51,
-	IOSDeviceUSBDriverError:  52,
+	DeviceUSBDriverError:  52,
-	IOSScreenShotError:       55,
+	DeviceShellExecError:  62,
-	IOSCaptureLogError:       56,
+	DeviceOfflineError:    63,
-
+	DeviceScreenShotError: 65,
-	// android related
+	DeviceCaptureLogError: 66,
-	AndroidDeviceConnectionError:        60,
-	AndroidDeviceConnectionRefusedError: 61,
-	AndroidShellExecError:               62,
-	AndroidDeviceOfflineError:           63,
-	AndroidScreenShotError:              65,
-	AndroidCaptureLogError:              66,
 
 	// UI automation related
 	MobileUIDriverError:                   70,

hrp/pkg/gadb/client.go

@@ -90,7 +90,7 @@ func (c Client) DeviceSerialList() (serials []string, err error) {
 func (c Client) DeviceList() (devices []*Device, err error) {
 	defer func() {
 		if err != nil && errors.Cause(err) == nil {
-			err = errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+			err = errors.Wrap(code.DeviceConnectionError, err.Error())
 		}
 	}()
 

hrp/pkg/gadb/device.go

@@ -327,7 +327,7 @@ func (d *Device) ReverseForwardKillAll() error {
 func (d *Device) RunShellCommand(cmd string, args ...string) (string, error) {
 	raw, err := d.RunShellCommandWithBytes(cmd, args...)
 	if err != nil && errors.Cause(err) == nil {
-		err = errors.Wrap(code.AndroidShellExecError, err.Error())
+		err = errors.Wrap(code.DeviceShellExecError, err.Error())
 	}
 	return string(raw), err
 }

hrp/pkg/gadb/transport.go

@@ -42,18 +42,18 @@ func newTransport(address string, readTimeout ...time.Duration) (tp transport, e
 
 	// connection refused
 	if strings.Contains(err.Error(), "connect: connection refused") {
-		err = errors.Wrap(code.AndroidDeviceConnectionRefusedError, err.Error())
+		err = errors.Wrap(code.DeviceConnectionError, err.Error())
 		return
 	}
 
 	// device offline
 	if regexDeviceOffline.MatchString(err.Error()) {
-		err = errors.Wrap(code.AndroidDeviceOfflineError, err.Error())
+		err = errors.Wrap(code.DeviceOfflineError, err.Error())
 		return
 	}
 
 	// other connection errors
-	err = errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+	err = errors.Wrap(code.DeviceConnectionError, err.Error())
 	return
 }
 

hrp/pkg/uixt/android_adb_driver.go

@@ -674,7 +674,7 @@ func (ad *adbDriver) StartCaptureLog(identifier ...string) (err error) {
 	// start logcat
 	err = ad.logcat.CatchLogcat("iesqaMonitor:V")
 	if err != nil {
-		err = errors.Wrap(code.AndroidCaptureLogError,
+		err = errors.Wrap(code.DeviceCaptureLogError,
 			fmt.Sprintf("start adb log recording failed: %v", err))
 		return err
 	}

hrp/pkg/uixt/android_device.go

@@ -112,11 +112,11 @@ func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, er
 	}
 	deviceList, err := GetAndroidDevices(device.SerialNumber)
 	if err != nil {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+		return nil, errors.Wrap(code.DeviceConnectionError, err.Error())
 	}
 
 	if device.SerialNumber == "" && len(deviceList) > 1 {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError, "more than one device connected, please specify the serial")
+		return nil, errors.Wrap(code.DeviceConnectionError, "more than one device connected, please specify the serial")
 	}
 
 	dev := deviceList[0]
@@ -137,7 +137,7 @@ func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, er
 	}
 	err = dev.Push(bytes.NewReader(evalToolRaw), "/data/local/tmp/evalite", time.Now())
 	if err != nil {
-		return nil, errors.Wrap(code.AndroidShellExecError, err.Error())
+		return nil, errors.Wrap(code.DeviceShellExecError, err.Error())
 	}
 	log.Info().Str("serial", device.SerialNumber).Msg("init android device")
 	return device, nil
@@ -240,7 +240,7 @@ func (dev *AndroidDevice) NewDriver(options ...DriverOption) (driverExt *DriverE
 func (dev *AndroidDevice) NewUSBDriver(capabilities Capabilities) (driver IWebDriver, err error) {
 	localPort, err := dev.d.Forward(UIA2ServerPort)
 	if err != nil {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+		return nil, errors.Wrap(code.DeviceConnectionError,
 			fmt.Sprintf("forward port %d->%d failed: %v",
 				localPort, UIA2ServerPort, err))
 	}
@@ -250,7 +250,7 @@ func (dev *AndroidDevice) NewUSBDriver(capabilities Capabilities) (driver IWebDr
 	uiaDriver, err := NewUIADriver(capabilities, rawURL)
 	if err != nil {
 		_ = dev.d.ForwardKill(localPort)
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+		return nil, errors.Wrap(code.DeviceConnectionError, err.Error())
 	}
 	uiaDriver.adbClient = dev.d
 	uiaDriver.logcat = dev.logcat
@@ -261,14 +261,14 @@ func (dev *AndroidDevice) NewUSBDriver(capabilities Capabilities) (driver IWebDr
 func (dev *AndroidDevice) NewStubDriver(capabilities Capabilities) (driver *stubAndroidDriver, err error) {
 	socketLocalPort, err := dev.d.Forward(StubSocketName)
 	if err != nil {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+		return nil, errors.Wrap(code.DeviceConnectionError,
 			fmt.Sprintf("forward port %d->%s failed: %v",
 				socketLocalPort, StubSocketName, err))
 	}
 
 	serverLocalPort, err := dev.d.Forward(DouyinServerPort)
 	if err != nil {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+		return nil, errors.Wrap(code.DeviceConnectionError,
 			fmt.Sprintf("forward port %d->%d failed: %v",
 				serverLocalPort, DouyinServerPort, err))
 	}
@@ -280,7 +280,7 @@ func (dev *AndroidDevice) NewStubDriver(capabilities Capabilities) (driver *stub
 	if err != nil {
 		_ = dev.d.ForwardKill(socketLocalPort)
 		_ = dev.d.ForwardKill(serverLocalPort)
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+		return nil, errors.Wrap(code.DeviceConnectionError, err.Error())
 	}
 	stubDriver.adbClient = dev.d
 	stubDriver.logcat = dev.logcat

hrp/pkg/uixt/ios_device.go

@@ -145,12 +145,12 @@ func WithIOSPcapOptions(options ...gidevice.PcapOption) IOSDeviceOption {
 func GetIOSDevices(udid ...string) (devices []gidevice.Device, err error) {
 	var usbmux gidevice.Usbmux
 	if usbmux, err = gidevice.NewUsbmux(); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceConnectionError,
+		return nil, errors.Wrap(code.DeviceConnectionError,
 			fmt.Sprintf("init usbmux failed: %v", err))
 	}
 
 	if devices, err = usbmux.Devices(); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceConnectionError,
+		return nil, errors.Wrap(code.DeviceConnectionError,
 			fmt.Sprintf("list ios devices failed: %v", err))
 	}
 
@@ -235,11 +235,11 @@ func NewIOSDevice(options ...IOSDeviceOption) (device *IOSDevice, err error) {
 
 	deviceList, err := GetIOSDevices(device.UDID)
 	if err != nil {
-		return nil, errors.Wrap(code.IOSDeviceConnectionError, err.Error())
+		return nil, errors.Wrap(code.DeviceConnectionError, err.Error())
 	}
 
 	if device.UDID == "" && len(deviceList) > 1 {
-		return nil, errors.Wrap(code.IOSDeviceConnectionError, "more than one device connected, please specify the udid")
+		return nil, errors.Wrap(code.DeviceConnectionError, "more than one device connected, please specify the udid")
 	}
 
 	dev := deviceList[0]
@@ -507,7 +507,7 @@ func (dev *IOSDevice) forward(localPort, remotePort int) error {
 			rInnerConn, err := device.NewConnect(remotePort)
 			if err != nil {
 				log.Error().Err(err).Msg("connect to ios device failed")
-				os.Exit(code.GetErrorCode(code.IOSDeviceConnectionError))
+				os.Exit(code.GetErrorCode(code.DeviceConnectionError))
 			}
 
 			rConn := rInnerConn.RawConn()
@@ -614,12 +614,12 @@ func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver IWebDrive
 	if err != nil {
 		localPort, err = builtin.GetFreePort()
 		if err != nil {
-			return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
+			return nil, errors.Wrap(code.DeviceHTTPDriverError,
 				fmt.Sprintf("get free port failed: %v", err))
 		}
 
 		if err = dev.forward(localPort, dev.Port); err != nil {
-			return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
+			return nil, errors.Wrap(code.DeviceHTTPDriverError,
 				fmt.Sprintf("forward tcp port failed: %v", err))
 		}
 	} else {
@@ -631,11 +631,11 @@ func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver IWebDrive
 	if err != nil {
 		localMjpegPort, err = builtin.GetFreePort()
 		if err != nil {
-			return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
+			return nil, errors.Wrap(code.DeviceHTTPDriverError,
 				fmt.Sprintf("get free port failed: %v", err))
 		}
 		if err = dev.forward(localMjpegPort, dev.MjpegPort); err != nil {
-			return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
+			return nil, errors.Wrap(code.DeviceHTTPDriverError,
 				fmt.Sprintf("forward tcp port failed: %v", err))
 		}
 	} else {
@@ -652,17 +652,17 @@ func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver IWebDrive
 
 	host := "localhost"
 	if wd.urlPrefix, err = url.Parse(fmt.Sprintf("http://%s:%d", host, localPort)); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
+		return nil, errors.Wrap(code.DeviceHTTPDriverError, err.Error())
 	}
 	if _, err = wd.NewSession(capabilities); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
+		return nil, errors.Wrap(code.DeviceHTTPDriverError, err.Error())
 	}
 
 	if wd.mjpegHTTPConn, err = net.Dial(
 		"tcp",
 		fmt.Sprintf("%s:%d", host, localMjpegPort),
 	); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
+		return nil, errors.Wrap(code.DeviceHTTPDriverError, err.Error())
 	}
 	wd.mjpegClient = convertToHTTPClient(wd.mjpegHTTPConn)
 
@@ -681,22 +681,22 @@ func (dev *IOSDevice) NewUSBDriver(capabilities Capabilities) (driver IWebDriver
 
 	wd := new(wdaDriver)
 	if wd.defaultConn, err = dev.d.NewConnect(dev.Port, 0); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceUSBDriverError,
+		return nil, errors.Wrap(code.DeviceUSBDriverError,
 			fmt.Sprintf("connect port %d failed: %v", dev.Port, err))
 	}
 	wd.client = convertToHTTPClient(wd.defaultConn.RawConn())
 
 	if wd.mjpegUSBConn, err = dev.d.NewConnect(dev.MjpegPort, 0); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceUSBDriverError,
+		return nil, errors.Wrap(code.DeviceUSBDriverError,
 			fmt.Sprintf("connect MJPEG port %d failed: %v", dev.MjpegPort, err))
 	}
 	wd.mjpegClient = convertToHTTPClient(wd.mjpegUSBConn.RawConn())
 
 	if wd.urlPrefix, err = url.Parse("http://" + dev.UDID); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceUSBDriverError, err.Error())
+		return nil, errors.Wrap(code.DeviceUSBDriverError, err.Error())
 	}
 	if _, err = wd.NewSession(capabilities); err != nil {
-		return nil, errors.Wrap(code.IOSDeviceUSBDriverError, err.Error())
+		return nil, errors.Wrap(code.DeviceUSBDriverError, err.Error())
 	}
 
 	// init WDA scale

hrp/pkg/uixt/ios_driver.go

@@ -742,13 +742,11 @@ func (wd *wdaDriver) Screenshot() (raw *bytes.Buffer, err error) {
 	// [[FBRoute GET:@"/screenshot"].withoutSession respondWithTarget:self action:@selector(handleGetScreenshot:)]
 	var rawResp rawResponse
 	if rawResp, err = wd.httpGET("/session", wd.session.ID, "/screenshot"); err != nil {
-		return nil, errors.Wrap(code.IOSScreenShotError,
+		return nil, errors.Wrap(err, "get WDA screenshot data failed")
-			fmt.Sprintf("get WDA screenshot data failed: %v", err))
 	}
 
 	if raw, err = rawResp.valueDecodeAsBase64(); err != nil {
-		return nil, errors.Wrap(code.IOSScreenShotError,
+		return nil, errors.Wrap(err, "decode WDA screenshot data failed")
-			fmt.Sprintf("decode WDA screenshot data failed: %v", err))
 	}
 	return
 }
@@ -874,7 +872,7 @@ func (wd *wdaDriver) StartCaptureLog(identifier ...string) error {
 	data := map[string]interface{}{"action": "start", "type": 2, "identifier": identifier[0]}
 	_, err := wd.triggerWDALog(data)
 	if err != nil {
-		return errors.Wrap(code.IOSCaptureLogError,
+		return errors.Wrap(code.DeviceCaptureLogError,
 			fmt.Sprintf("start WDA log recording failed: %v", err))
 	}
 
@@ -892,13 +890,13 @@ func (wd *wdaDriver) StopCaptureLog() (result interface{}, err error) {
 	rawResp, err := wd.triggerWDALog(data)
 	if err != nil {
 		log.Error().Err(err).Bytes("rawResp", rawResp).Msg("failed to get WDA logs")
-		return "", errors.Wrap(code.IOSCaptureLogError,
+		return "", errors.Wrap(code.DeviceCaptureLogError,
 			fmt.Sprintf("get WDA logs failed: %v", err))
 	}
 	reply := new(wdaResponse)
 	if err = json.Unmarshal(rawResp, reply); err != nil {
 		log.Error().Err(err).Bytes("rawResp", rawResp).Msg("failed to json.Unmarshal WDA logs")
-		return reply, errors.Wrap(code.IOSCaptureLogError,
+		return reply, errors.Wrap(code.DeviceCaptureLogError,
 			fmt.Sprintf("json.Unmarshal WDA logs failed: %v", err))
 	}
 	log.Info().Interface("value", reply.Value).Msg("get WDA log response")

hrp/pkg/uixt/screenshot.go

@@ -14,6 +14,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 
+	"github.com/httprunner/httprunner/v4/hrp/code"
 	"github.com/httprunner/httprunner/v4/hrp/internal/builtin"
 	"github.com/httprunner/httprunner/v4/hrp/internal/env"
 )
@@ -152,14 +153,15 @@ func (dExt *DriverExt) FindUIResult(options ...ActionOption) (point PointF, err
 func (dExt *DriverExt) GetScreenShot(fileName string) (raw *bytes.Buffer, path string, err error) {
 	if raw, err = dExt.Driver.Screenshot(); err != nil {
 		log.Error().Err(err).Msg("capture screenshot data failed")
-		return nil, "", err
+		return nil, "", errors.Wrap(code.DeviceScreenShotError, err.Error())
 	}
 
 	// compress image data
 	compressed, err := compressImageBuffer(raw)
 	if err != nil {
 		log.Error().Err(err).Msg("compress screenshot data failed")
-		return nil, "", err
+		return nil, "", errors.Wrap(code.DeviceScreenShotError,
+			fmt.Sprintf("compress screenshot data failed: %s", err.Error()))
 	}
 
 	// save screenshot to file
@@ -167,8 +169,10 @@ func (dExt *DriverExt) GetScreenShot(fileName string) (raw *bytes.Buffer, path s
 	path, err = saveScreenShot(compressed, path)
 	if err != nil {
 		log.Error().Err(err).Msg("save screenshot file failed")
-		return nil, "", err
+		return nil, "", errors.Wrap(code.DeviceScreenShotError,
+			fmt.Sprintf("save screenshot file failed: %s", err.Error()))
 	}
+	log.Debug().Str("path", path).Msg("save screenshot file success")
 	return compressed, path, nil
 }