GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-05-11 18:11:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: hrp code

Browse Source
This commit is contained in:
lilong.129
2024-09-12 10:45:52 +08:00
parent 9fc9e8620f
commit 6f6cefe4bc
9 changed files with 61 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
hrp/code/code.go
View File

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

2
hrp/pkg/gadb/client.go
View File

@@ -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())
}
}()

2
hrp/pkg/gadb/device.go
View File

@@ -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
}

6
hrp/pkg/gadb/transport.go
View File

@@ -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
}

2
hrp/pkg/uixt/android_adb_driver.go
View File

@@ -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
}

16
hrp/pkg/uixt/android_device.go
View File

@@ -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

32
hrp/pkg/uixt/ios_device.go
View File

@@ -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

12
hrp/pkg/uixt/ios_driver.go
View File

@@ -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,
fmt.Sprintf("get WDA screenshot data failed: %v", err))
return nil, errors.Wrap(err, "get WDA screenshot data failed")
}
if raw, err = rawResp.valueDecodeAsBase64(); err != nil {
return nil, errors.Wrap(code.IOSScreenShotError,
fmt.Sprintf("decode WDA screenshot data failed: %v", err))
return nil, errors.Wrap(err, "decode WDA screenshot data failed")
}
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")

10
hrp/pkg/uixt/screenshot.go
View File

@@ -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
}