GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-07-12 07:52:13 +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

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
}