817 lines
22 KiB
Go
817 lines
22 KiB
Go
package hrp
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"github.com/httprunner/httprunner/v5/code"
|
|
"github.com/httprunner/httprunner/v5/internal/sdk"
|
|
"github.com/httprunner/httprunner/v5/pkg/uixt"
|
|
)
|
|
|
|
type MobileUI struct {
|
|
OSType string `json:"os_type,omitempty" yaml:"os_type,omitempty"` // ios or harmony or android
|
|
Serial string `json:"serial,omitempty" yaml:"serial,omitempty"` // android serial or ios udid
|
|
uixt.MobileAction `yaml:",inline"`
|
|
Actions []uixt.MobileAction `json:"actions,omitempty" yaml:"actions,omitempty"`
|
|
}
|
|
|
|
// StepMobile implements IStep interface.
|
|
type StepMobile struct {
|
|
StepConfig
|
|
Mobile *MobileUI `json:"mobile,omitempty" yaml:"mobile,omitempty"`
|
|
Android *MobileUI `json:"android,omitempty" yaml:"android,omitempty"`
|
|
Harmony *MobileUI `json:"harmony,omitempty" yaml:"harmony,omitempty"`
|
|
IOS *MobileUI `json:"ios,omitempty" yaml:"ios,omitempty"`
|
|
|
|
cache *MobileUI // used for caching
|
|
}
|
|
|
|
// uniform interface for all types of mobile systems
|
|
func (s *StepMobile) obj() *MobileUI {
|
|
if s.cache != nil {
|
|
return s.cache
|
|
}
|
|
|
|
if s.IOS != nil {
|
|
s.cache = s.IOS
|
|
s.cache.OSType = string(StepTypeIOS)
|
|
return s.cache
|
|
} else if s.Harmony != nil {
|
|
s.cache = s.Harmony
|
|
s.cache.OSType = string(StepTypeHarmony)
|
|
return s.cache
|
|
} else if s.Android != nil {
|
|
s.cache = s.Android
|
|
s.cache.OSType = string(StepTypeAndroid)
|
|
return s.cache
|
|
} else if s.Mobile != nil {
|
|
s.cache = s.Mobile
|
|
return s.cache
|
|
}
|
|
|
|
panic("no mobile device config")
|
|
}
|
|
|
|
func (s *StepMobile) Serial(serial string) *StepMobile {
|
|
s.obj().Serial = serial
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) Log(actionName uixt.ActionMethod) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_LOG,
|
|
Params: actionName,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) InstallApp(path string) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_AppInstall,
|
|
Params: path,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) AppLaunch(bundleId string) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_AppLaunch,
|
|
Params: bundleId,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) AppTerminate(bundleId string) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_AppTerminate,
|
|
Params: bundleId,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) Home() *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_Home,
|
|
Params: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
// TapXY taps the point {X,Y}, X & Y is percentage of coordinates
|
|
func (s *StepMobile) TapXY(x, y float64, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_TapXY,
|
|
Params: []float64{x, y},
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// TapAbsXY taps the point {X,Y}, X & Y is absolute coordinates
|
|
func (s *StepMobile) TapAbsXY(x, y float64, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_TapAbsXY,
|
|
Params: []float64{x, y},
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// Tap taps on the target element
|
|
func (s *StepMobile) Tap(params string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Tap,
|
|
Params: params,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// TapByOCR taps on the target element by OCR recognition
|
|
func (s *StepMobile) TapByOCR(ocrText string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_TapByOCR,
|
|
Params: ocrText,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// TapByCV taps on the target element by CV recognition
|
|
func (s *StepMobile) TapByCV(imagePath string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_TapByCV,
|
|
Params: imagePath,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// TapByUITypes taps on the target element specified by uiTypes, the higher the uiTypes, the higher the priority
|
|
func (s *StepMobile) TapByUITypes(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_TapByCV,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// DoubleTapXY double taps the point {X,Y}, X & Y is percentage of coordinates
|
|
func (s *StepMobile) DoubleTapXY(x, y float64, options ...uixt.ActionOption) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_DoubleTapXY,
|
|
Params: []float64{x, y},
|
|
Options: uixt.NewActionOptions(options...),
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) DoubleTap(params string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_DoubleTap,
|
|
Params: params,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) Back(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Back,
|
|
Params: nil,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// Swipe drags from [sx, sy] to [ex, ey]
|
|
func (s *StepMobile) Swipe(sx, sy, ex, ey float64, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Swipe,
|
|
Params: []float64{sx, sy, ex, ey},
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeUp(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Swipe,
|
|
Params: "up",
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeDown(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Swipe,
|
|
Params: "down",
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeLeft(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Swipe,
|
|
Params: "left",
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeRight(options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Swipe,
|
|
Params: "right",
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeToTapApp(appName string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_SwipeToTapApp,
|
|
Params: appName,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeToTapText(text string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_SwipeToTapText,
|
|
Params: text,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SwipeToTapTexts(texts interface{}, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_SwipeToTapTexts,
|
|
Params: texts,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) Input(text string, options ...uixt.ActionOption) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Input,
|
|
Params: text,
|
|
Options: uixt.NewActionOptions(options...),
|
|
}
|
|
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// Sleep specify sleep seconds after last action
|
|
func (s *StepMobile) Sleep(nSeconds float64, startTime ...time.Time) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_Sleep,
|
|
Params: nSeconds,
|
|
Options: nil,
|
|
}
|
|
if len(startTime) > 0 {
|
|
action.Params = uixt.SleepConfig{
|
|
StartTime: startTime[0],
|
|
Seconds: nSeconds,
|
|
}
|
|
}
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) SleepMS(nMilliseconds int64, startTime ...time.Time) *StepMobile {
|
|
action := uixt.MobileAction{
|
|
Method: uixt.ACTION_SleepMS,
|
|
Params: nMilliseconds,
|
|
Options: nil,
|
|
}
|
|
if len(startTime) > 0 {
|
|
action.Params = uixt.SleepConfig{
|
|
StartTime: startTime[0],
|
|
Milliseconds: nMilliseconds,
|
|
}
|
|
}
|
|
s.obj().Actions = append(s.obj().Actions, action)
|
|
return s
|
|
}
|
|
|
|
// SleepRandom specify random sleeping seconds after last action
|
|
// params have two different kinds:
|
|
// 1. [min, max] : min and max are float64 time range boundaries
|
|
// 2. [min1, max1, weight1, min2, max2, weight2, ...] : weight is the probability of the time range
|
|
func (s *StepMobile) SleepRandom(params ...float64) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_SleepRandom,
|
|
Params: params,
|
|
Options: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) EndToEndDelay(options ...uixt.ActionOption) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_EndToEndDelay,
|
|
Params: nil,
|
|
Options: uixt.NewActionOptions(options...),
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) ScreenShot(options ...uixt.ActionOption) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_ScreenShot,
|
|
Params: nil,
|
|
Options: uixt.NewActionOptions(options...),
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) StartCamera() *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_StartCamera,
|
|
Params: nil,
|
|
Options: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) StopCamera() *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_StopCamera,
|
|
Params: nil,
|
|
Options: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) DisableAutoPopupHandler() *StepMobile {
|
|
s.IgnorePopup = true
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) ClosePopups(options ...uixt.ActionOption) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_ClosePopups,
|
|
Params: nil,
|
|
Options: uixt.NewActionOptions(options...),
|
|
})
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobile) Call(name string, fn func()) *StepMobile {
|
|
s.obj().Actions = append(s.obj().Actions, uixt.MobileAction{
|
|
Method: uixt.ACTION_CallFunction,
|
|
Params: name, // function description
|
|
Fn: fn,
|
|
Options: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
// Validate switches to step validation.
|
|
func (s *StepMobile) Validate() *StepMobileUIValidation {
|
|
return &StepMobileUIValidation{
|
|
StepMobile: s,
|
|
Validators: make([]interface{}, 0),
|
|
}
|
|
}
|
|
|
|
func (s *StepMobile) Name() string {
|
|
return s.StepName
|
|
}
|
|
|
|
func (s *StepMobile) Type() StepType {
|
|
osType := s.obj().OSType
|
|
if osType != "" {
|
|
return StepType(osType)
|
|
}
|
|
return StepType("mobile")
|
|
}
|
|
|
|
func (s *StepMobile) Config() *StepConfig {
|
|
return &s.StepConfig
|
|
}
|
|
|
|
func (s *StepMobile) Run(r *SessionRunner) (*StepResult, error) {
|
|
return runStepMobileUI(r, s)
|
|
}
|
|
|
|
// StepMobileUIValidation implements IStep interface.
|
|
type StepMobileUIValidation struct {
|
|
*StepMobile
|
|
Validators []interface{} `json:"validate,omitempty" yaml:"validate,omitempty"`
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertNameExists(expectedName string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorName,
|
|
Assert: uixt.AssertionExists,
|
|
Expect: expectedName,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("attribute name [%s] not found", expectedName)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertNameNotExists(expectedName string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorName,
|
|
Assert: uixt.AssertionNotExists,
|
|
Expect: expectedName,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("attribute name [%s] should not exist", expectedName)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertLabelExists(expectedLabel string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorLabel,
|
|
Assert: uixt.AssertionExists,
|
|
Expect: expectedLabel,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("attribute label [%s] not found", expectedLabel)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertLabelNotExists(expectedLabel string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorLabel,
|
|
Assert: uixt.AssertionNotExists,
|
|
Expect: expectedLabel,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("attribute label [%s] should not exist", expectedLabel)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertOCRExists(expectedText string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorOCR,
|
|
Assert: uixt.AssertionExists,
|
|
Expect: expectedText,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("ocr text [%s] not found", expectedText)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertOCRNotExists(expectedText string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorOCR,
|
|
Assert: uixt.AssertionNotExists,
|
|
Expect: expectedText,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("ocr text [%s] should not exist", expectedText)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertImageExists(expectedImagePath string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorImage,
|
|
Assert: uixt.AssertionExists,
|
|
Expect: expectedImagePath,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("cv image [%s] not found", expectedImagePath)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertImageNotExists(expectedImagePath string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorImage,
|
|
Assert: uixt.AssertionNotExists,
|
|
Expect: expectedImagePath,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("cv image [%s] should not exist", expectedImagePath)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertAppInForeground(packageName string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorForegroundApp,
|
|
Assert: uixt.AssertionEqual,
|
|
Expect: packageName,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("app [%s] should be in foreground", packageName)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) AssertAppNotInForeground(packageName string, msg ...string) *StepMobileUIValidation {
|
|
v := Validator{
|
|
Check: uixt.SelectorForegroundApp,
|
|
Assert: uixt.AssertionNotEqual,
|
|
Expect: packageName,
|
|
}
|
|
if len(msg) > 0 {
|
|
v.Message = msg[0]
|
|
} else {
|
|
v.Message = fmt.Sprintf("app [%s] should not be in foreground", packageName)
|
|
}
|
|
s.Validators = append(s.Validators, v)
|
|
return s
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) Name() string {
|
|
return s.StepName
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) Type() StepType {
|
|
return s.StepMobile.Type() + stepTypeSuffixValidation
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) Config() *StepConfig {
|
|
return &StepConfig{
|
|
StepName: s.StepName,
|
|
Variables: s.Variables,
|
|
Validators: s.Validators,
|
|
}
|
|
}
|
|
|
|
func (s *StepMobileUIValidation) Run(r *SessionRunner) (*StepResult, error) {
|
|
return runStepMobileUI(r, s)
|
|
}
|
|
|
|
func runStepMobileUI(s *SessionRunner, step IStep) (stepResult *StepResult, err error) {
|
|
var stepVariables map[string]interface{}
|
|
var stepValidators []interface{}
|
|
var ignorePopup bool
|
|
|
|
var mobileStep *MobileUI
|
|
switch stepMobile := step.(type) {
|
|
case *StepMobile:
|
|
mobileStep = stepMobile.obj()
|
|
stepVariables = stepMobile.Variables
|
|
ignorePopup = stepMobile.IgnorePopup
|
|
case *StepMobileUIValidation:
|
|
mobileStep = stepMobile.obj()
|
|
stepVariables = stepMobile.Variables
|
|
stepValidators = stepMobile.Validators
|
|
ignorePopup = stepMobile.StepMobile.IgnorePopup
|
|
default:
|
|
return nil, errors.New("invalid mobile UI step type")
|
|
}
|
|
|
|
// report GA event
|
|
go sdk.SendGA4Event("hrp_run_ui", map[string]interface{}{
|
|
"osType": mobileStep.OSType,
|
|
})
|
|
|
|
// init wda/uia/hdc driver
|
|
uiDriver, err := s.caseRunner.GetUIXTDriver(mobileStep.Serial)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
identifier := mobileStep.Identifier
|
|
if mobileStep.Options != nil && identifier == "" {
|
|
identifier = mobileStep.Options.Identifier
|
|
}
|
|
if len(mobileStep.Actions) != 0 && identifier == "" {
|
|
for _, action := range mobileStep.Actions {
|
|
if action.Identifier != "" {
|
|
identifier = action.Identifier
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
start := time.Now()
|
|
stepResult = &StepResult{
|
|
Name: step.Name(),
|
|
Identifier: identifier,
|
|
StepType: step.Type(),
|
|
Success: false,
|
|
ContentSize: 0,
|
|
StartTime: start.Unix(),
|
|
}
|
|
|
|
defer func() {
|
|
attachments := uixt.Attachments{}
|
|
if err != nil {
|
|
attachments["error"] = err.Error()
|
|
|
|
// save foreground app
|
|
startTime := time.Now()
|
|
actionResult := &ActionResult{
|
|
MobileAction: uixt.MobileAction{
|
|
Method: uixt.ACTION_GetForegroundApp,
|
|
Params: "[ForDebug] check foreground app",
|
|
},
|
|
StartTime: startTime.Unix(),
|
|
}
|
|
if app, err1 := uiDriver.Driver.GetForegroundApp(); err1 == nil {
|
|
attachments["foreground_app"] = app.AppBaseInfo
|
|
} else {
|
|
log.Warn().Err(err1).Msg("save foreground app failed, ignore")
|
|
}
|
|
actionResult.Elapsed = time.Since(startTime).Milliseconds()
|
|
stepResult.Actions = append(stepResult.Actions, actionResult)
|
|
}
|
|
|
|
// automatic handling of pop-up windows on each step finished
|
|
if !ignorePopup && !s.caseRunner.Config.Get().IgnorePopup {
|
|
startTime := time.Now()
|
|
actionResult := &ActionResult{
|
|
MobileAction: uixt.MobileAction{
|
|
Method: uixt.ACTION_ClosePopups,
|
|
Params: "[ForDebug] close popups handler",
|
|
},
|
|
StartTime: startTime.Unix(),
|
|
}
|
|
if err2 := uiDriver.ClosePopupsHandler(); err2 != nil {
|
|
log.Error().Err(err2).Str("step", step.Name()).Msg("auto handle popup failed")
|
|
}
|
|
actionResult.Elapsed = time.Since(startTime).Milliseconds()
|
|
stepResult.Actions = append(stepResult.Actions, actionResult)
|
|
}
|
|
|
|
// save attachments
|
|
session := uiDriver.Driver.GetSession()
|
|
for key, value := range session.Get(true) {
|
|
attachments[key] = value
|
|
}
|
|
stepResult.Attachments = attachments
|
|
stepResult.Elapsed = time.Since(start).Milliseconds()
|
|
}()
|
|
|
|
// run actions
|
|
for _, action := range mobileStep.Actions {
|
|
select {
|
|
case <-s.caseRunner.hrpRunner.caseTimeoutTimer.C:
|
|
log.Warn().Msg("timeout in mobile UI runner")
|
|
return stepResult, errors.Wrap(code.TimeoutError, "mobile UI runner timeout")
|
|
case <-s.caseRunner.hrpRunner.interruptSignal:
|
|
log.Warn().Msg("interrupted in mobile UI runner")
|
|
return stepResult, errors.Wrap(code.InterruptError, "mobile UI runner interrupted")
|
|
default:
|
|
actionStartTime := time.Now()
|
|
actionResult := &ActionResult{
|
|
MobileAction: action,
|
|
StartTime: actionStartTime.Unix(), // action 开始时间
|
|
}
|
|
if action.Params, err = s.caseRunner.parser.Parse(action.Params, stepVariables); err != nil {
|
|
if !code.IsErrorPredefined(err) {
|
|
err = errors.Wrap(code.ParseError,
|
|
fmt.Sprintf("parse action params failed: %v", err))
|
|
}
|
|
return stepResult, err
|
|
}
|
|
|
|
// stat uixt action
|
|
if action.Method == uixt.ACTION_LOG {
|
|
log.Info().Interface("action", action.Params).Msg("stat uixt action")
|
|
actionMethod := uixt.ActionMethod(action.Params.(string))
|
|
s.summary.Stat.Actions[actionMethod]++
|
|
continue
|
|
}
|
|
|
|
err = uiDriver.DoAction(action)
|
|
actionResult.Elapsed = time.Since(actionStartTime).Milliseconds()
|
|
stepResult.Actions = append(stepResult.Actions, actionResult)
|
|
if err != nil {
|
|
if !code.IsErrorPredefined(err) {
|
|
err = errors.Wrap(code.MobileUIDriverError, err.Error())
|
|
}
|
|
return stepResult, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// validate
|
|
validateResults, err := validateUI(uiDriver, stepValidators)
|
|
if err != nil {
|
|
if !code.IsErrorPredefined(err) {
|
|
err = errors.Wrap(code.MobileUIValidationError, err.Error())
|
|
}
|
|
return
|
|
}
|
|
if len(validateResults) > 0 {
|
|
sessionData := &SessionData{
|
|
Validators: validateResults,
|
|
}
|
|
stepResult.Data = sessionData
|
|
}
|
|
stepResult.Success = true
|
|
return stepResult, nil
|
|
}
|
|
|
|
func validateUI(ud *uixt.DriverExt, iValidators []interface{}) (validateResults []*ValidationResult, err error) {
|
|
for _, iValidator := range iValidators {
|
|
validator, ok := iValidator.(Validator)
|
|
if !ok {
|
|
return nil, errors.New("validator type error")
|
|
}
|
|
|
|
validataResult := &ValidationResult{
|
|
Validator: validator,
|
|
CheckResult: "fail",
|
|
}
|
|
|
|
// parse check value
|
|
if !strings.HasPrefix(validator.Check, "ui_") {
|
|
validataResult.CheckResult = "skip"
|
|
log.Warn().Interface("validator", validator).Msg("skip validator")
|
|
validateResults = append(validateResults, validataResult)
|
|
continue
|
|
}
|
|
|
|
expected, ok := validator.Expect.(string)
|
|
if !ok {
|
|
return nil, errors.New("validator expect should be string")
|
|
}
|
|
|
|
err := ud.DoValidation(validator.Check, validator.Assert, expected, validator.Message)
|
|
if err != nil {
|
|
return validateResults, errors.Wrap(err, "step validation failed")
|
|
}
|
|
|
|
validataResult.CheckResult = "pass"
|
|
validateResults = append(validateResults, validataResult)
|
|
}
|
|
return validateResults, nil
|
|
}
|