GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-07-10 23:12:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: add status code for mobile UI

Browse Source
This commit is contained in:
debugtalk
2022-10-19 11:48:40 +08:00
parent ec9b81ca2e
commit 8947c0ad5a
11 changed files with 106 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,7 @@ import (
"github.com/pkg/errors"
"github.com/rs/zerolog/log"
"github.com/httprunner/httprunner/v4/hrp/internal/code"
"github.com/httprunner/httprunner/v4/hrp/internal/json"
"github.com/httprunner/httprunner/v4/hrp/internal/myexec"
)
@@ -71,7 +72,8 @@ func GetAndroidDeviceOptions(dev *AndroidDevice) (deviceOptions []AndroidDeviceO
func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, err error) {
deviceList, err := DeviceList()
if err != nil {
return nil, fmt.Errorf("get attached devices failed: %v", err)
return nil, errors.Wrap(code.AndroidDeviceConnectionError,
fmt.Sprintf("get attached devices failed: %v", err))
}
device = &AndroidDevice{
@@ -95,13 +97,14 @@ func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, er
return device, nil
}
return nil, fmt.Errorf("device %s not found", device.SerialNumber)
return nil, errors.Wrap(code.AndroidDeviceConnectionError,
fmt.Sprintf("device %s not found", device.SerialNumber))
}
func DeviceList() (devices []gadb.Device, err error) {
var adbClient gadb.Client
if adbClient, err = gadb.NewClientWith(AdbServerHost, AdbServerPort); err != nil {
return nil, err
return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
}
return adbClient.DeviceList()

9
hrp/pkg/uixt/android_driver.go
View File

@@ -963,7 +963,12 @@ func (ud *uiaDriver) Wait(condition Condition) error {
func (ud *uiaDriver) StartCaptureLog(identifier ...string) (err error) {
log.Info().Msg("start adb log recording")
err = ud.logcat.CatchLogcat()
return
if err != nil {
err = errors.Wrap(code.IOSCaptureLogError,
fmt.Sprintf("start adb log recording failed: %v", err))
return err
}
return nil
}
func (ud *uiaDriver) StopCaptureLog() (result interface{}, err error) {
@@ -971,6 +976,8 @@ func (ud *uiaDriver) StopCaptureLog() (result interface{}, err error) {
err = ud.logcat.Stop()
if err != nil {
log.Error().Err(err).Msg("failed to get adb log recording")
err = errors.Wrap(code.IOSCaptureLogError,
fmt.Sprintf("get adb log recording failed: %v", err))
return "", err
}
content := ud.logcat.logBuffer.String()

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

@@ -20,6 +20,7 @@ import (
"github.com/pkg/errors"
"github.com/rs/zerolog/log"
"github.com/httprunner/httprunner/v4/hrp/internal/code"
"github.com/httprunner/httprunner/v4/hrp/internal/env"
"github.com/httprunner/httprunner/v4/hrp/internal/json"
)
@@ -106,11 +107,13 @@ func WithPerfOptions(options ...giDevice.PerfOption) IOSDeviceOption {
func IOSDevices(udid ...string) (devices []giDevice.Device, err error) {
var usbmux giDevice.Usbmux
if usbmux, err = giDevice.NewUsbmux(); err != nil {
return nil, fmt.Errorf("init usbmux failed: %v", err)
return nil, errors.Wrap(code.IOSDeviceConnectionError,
fmt.Sprintf("init usbmux failed: %v", err))
}
if devices, err = usbmux.Devices(); err != nil {
return nil, fmt.Errorf("list ios devices failed: %v", err)
return nil, errors.Wrap(code.IOSDeviceConnectionError,
fmt.Sprintf("list ios devices failed: %v", err))
}
// filter by udid
@@ -185,7 +188,8 @@ func NewIOSDevice(options ...IOSDeviceOption) (device *IOSDevice, err error) {
return device, nil
}
return nil, fmt.Errorf("device %s not found", device.UDID)
return nil, errors.Wrap(code.IOSDeviceConnectionError,
fmt.Sprintf("device %s not found", device.UDID))
}
type IOSDevice struct {
@@ -230,13 +234,15 @@ func (dev *IOSDevice) NewDriver(capabilities Capabilities) (driverExt *DriverExt
if dev.ResetHomeOnStartup {
log.Info().Msg("go back to home screen")
if err = driver.Homescreen(); err != nil {
return nil, errors.Wrap(err, "failed to go back to home screen")
return nil, errors.Wrap(code.MobileUIDriverError,
fmt.Sprintf("go back to home screen failed: %v", err))
}
}
driverExt, err = Extend(driver)
if err != nil {
return nil, errors.Wrap(err, "failed to extend WebDriver")
return nil, errors.Wrap(code.MobileUIDriverError,
fmt.Sprintf("extend WebDriver failed: %v", err))
}
settings, err := driverExt.Driver.SetAppiumSettings(map[string]interface{}{
"snapshotMaxDepth": dev.SnapshotMaxDepth,
@@ -380,17 +386,21 @@ func (dev *IOSDevice) perfOpitons() (perfOptions []giDevice.PerfOption) {
func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver WebDriver, err error) {
localPort, err := getFreePort()
if err != nil {
return nil, errors.Wrap(err, "get free port failed")
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
fmt.Sprintf("get free port failed: %v", err))
}
if err = dev.forward(localPort, dev.Port); err != nil {
return nil, errors.Wrap(err, "forward tcp port failed")
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
fmt.Sprintf("forward tcp port failed: %v", err))
}
localMjpegPort, err := getFreePort()
if err != nil {
return nil, errors.Wrap(err, "get free port failed")
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
fmt.Sprintf("get free port failed: %v", err))
}
if err = dev.forward(localMjpegPort, dev.MjpegPort); err != nil {
return nil, errors.Wrap(err, "forward tcp port failed")
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError,
fmt.Sprintf("forward tcp port failed: %v", err))
}
log.Info().Interface("capabilities", capabilities).
@@ -402,11 +412,11 @@ func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver WebDriver
host := "127.0.0.1"
if wd.urlPrefix, err = url.Parse(fmt.Sprintf("http://%s:%d", host, localPort)); err != nil {
return nil, err
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
}
var sessionInfo SessionInfo
if sessionInfo, err = wd.NewSession(capabilities); err != nil {
return nil, err
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
}
wd.sessionId = sessionInfo.SessionId
@@ -414,7 +424,7 @@ func (dev *IOSDevice) NewHTTPDriver(capabilities Capabilities) (driver WebDriver
"tcp",
fmt.Sprintf("%s:%d", host, localMjpegPort),
); err != nil {
return nil, err
return nil, errors.Wrap(code.IOSDeviceHTTPDriverError, err.Error())
}
wd.mjpegClient = convertToHTTPClient(wd.mjpegHTTPConn)
@@ -428,23 +438,25 @@ func (dev *IOSDevice) NewUSBDriver(capabilities Capabilities) (driver WebDriver,
wd := new(wdaDriver)
if wd.defaultConn, err = dev.d.NewConnect(dev.Port, 0); err != nil {
return nil, fmt.Errorf("connect port %d failed: %w",
dev.Port, err)
return nil, errors.Wrap(code.IOSDeviceUSBDriverError,
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, fmt.Errorf("connect MJPEG port %d failed: %w",
dev.MjpegPort, err)
return nil, errors.Wrap(code.IOSDeviceUSBDriverError,
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, err
return nil, errors.Wrap(code.IOSDeviceUSBDriverError, err.Error())
}
if _, err = wd.NewSession(capabilities); err != nil {
return nil, errors.Wrap(code.IOSDeviceUSBDriverError, err.Error())
}
_, err = wd.NewSession(capabilities)
return wd, err
return wd, nil
}
func (dExt *DriverExt) ConnectMjpegStream(httpClient *http.Client) (err error) {

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

@@ -858,7 +858,8 @@ 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(err, "failed to start WDA log recording")
return errors.Wrap(code.IOSCaptureLogError,
fmt.Sprintf("start WDA log recording failed: %v", err))
}
return nil
@@ -875,12 +876,14 @@ 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(err, "failed to get WDA logs")
return "", errors.Wrap(code.IOSCaptureLogError,
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, err
return reply, errors.Wrap(code.IOSCaptureLogError,
fmt.Sprintf("json.Unmarshal WDA logs failed: %v", err))
}
log.Info().Interface("value", reply.Value).Msg("get WDA log response")
return reply.Value, nil