refactor: get attached android/ios devices

hrp/cmd/adb/devices.go

@@ -5,10 +5,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 
-	"github.com/httprunner/httprunner/v4/hrp/pkg/gadb"
 	"github.com/httprunner/httprunner/v4/hrp/pkg/uixt"
 )
 
@@ -21,22 +19,10 @@ var listAndroidDevicesCmd = &cobra.Command{
 	Use:   "devices",
 	Short: "List all Android devices",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		devices, err := uixt.DeviceList()
+		deviceList, err := uixt.GetAndroidDevices(serial)
 		if err != nil {
-			return errors.Wrap(err, "list android devices failed")
+			fmt.Println(err)
-		}
+			os.Exit(0)
-
-		var deviceList []*gadb.Device
-		// filter by serial
-		for _, d := range devices {
-			if serial != "" && serial != d.Serial() {
-				continue
-			}
-			deviceList = append(deviceList, d)
-		}
-		if serial != "" && len(deviceList) == 0 {
-			fmt.Printf("no android device found for serial: %s\n", serial)
-			os.Exit(1)
 		}
 
 		for _, d := range deviceList {

hrp/cmd/ios/devices.go

@@ -70,18 +70,10 @@ var listDevicesCmd = &cobra.Command{
 	Short:            "List all iOS devices",
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {},
 	RunE: func(cmd *cobra.Command, args []string) error {
-		devices, err := uixt.IOSDevices(udid)
+		devices, err := uixt.GetIOSDevices(udid)
 		if err != nil {
-			return err
+			fmt.Println(err)
-		}
+			os.Exit(0)
-		if len(devices) == 0 {
-			if udid != "" {
-				fmt.Printf("no ios device found for udid: %s\n", udid)
-				os.Exit(1)
-			} else {
-				fmt.Println("no ios device found")
-				os.Exit(0)
-			}
 		}
 
 		for _, d := range devices {

hrp/cmd/ios/init.go

@@ -2,7 +2,6 @@ package ios
 
 import (
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 
@@ -16,16 +15,12 @@ var iosRootCmd = &cobra.Command{
 }
 
 func getDevice(udid string) (gidevice.Device, error) {
-	devices, err := uixt.IOSDevices(udid)
+	devices, err := uixt.GetIOSDevices(udid)
 	if err != nil {
 		return nil, err
 	}
-	if len(devices) == 0 {
-		fmt.Println("no ios device found")
-		os.Exit(1)
-	}
 	if len(devices) > 1 {
-		return nil, fmt.Errorf("multiple devices found, please specify udid")
+		return nil, fmt.Errorf("multiple devices found, please specify ios udid")
 	}
 	return devices[0], nil
 }

hrp/pkg/uixt/android_device.go

@@ -81,15 +81,6 @@ func GetAndroidDeviceOptions(dev *AndroidDevice) (deviceOptions []AndroidDeviceO
 // uiautomator2 server must be started before
 // adb shell am instrument -w io.appium.uiautomator2.server.test/androidx.test.runner.AndroidJUnitRunner
 func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, err error) {
-	deviceList, err := DeviceList()
-	if err != nil {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
-			fmt.Sprintf("get attached devices failed: %v", err))
-	} else if len(deviceList) == 0 {
-		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
-			"not attached device found")
-	}
-
 	device = &AndroidDevice{
 		UIA2IP:   UIA2ServerHost,
 		UIA2Port: UIA2ServerPort,
@@ -98,30 +89,52 @@ func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, er
 		option(device)
 	}
 
-	serialNumber := device.SerialNumber
+	deviceList, err := GetAndroidDevices(device.SerialNumber)
-	for _, dev := range deviceList {
+	if err != nil {
-		// find device by serial number if specified
+		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
-		if serialNumber != "" && dev.Serial() != serialNumber {
-			continue
-		}
-
-		device.SerialNumber = dev.Serial()
-		device.d = dev
-		device.logcat = NewAdbLogcat(device.SerialNumber)
-		return device, nil
 	}
 
-	return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+	dev := deviceList[0]
-		fmt.Sprintf("device %s not found", device.SerialNumber))
+	device.SerialNumber = dev.Serial()
+	device.d = dev
+	device.logcat = NewAdbLogcat(device.SerialNumber)
+
+	log.Info().Str("serial", device.SerialNumber).Msg("select android device")
+	return device, nil
 }
 
-func DeviceList() (devices []*gadb.Device, err error) {
+func GetAndroidDevices(serial ...string) (devices []*gadb.Device, err error) {
 	var adbClient gadb.Client
 	if adbClient, err = gadb.NewClientWith(AdbServerHost, AdbServerPort); err != nil {
 		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
 	}
 
-	return adbClient.DeviceList()
+	if devices, err = adbClient.DeviceList(); err != nil {
+		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+			fmt.Sprintf("list android devices failed: %v", err))
+	}
+
+	var deviceList []*gadb.Device
+	// filter by serial
+	for _, d := range devices {
+		for _, s := range serial {
+			if s != "" && s != d.Serial() {
+				continue
+			}
+			deviceList = append(deviceList, d)
+		}
+	}
+
+	if len(deviceList) == 0 {
+		var err error
+		if serial == nil || (len(serial) == 1 && serial[0] == "") {
+			err = fmt.Errorf("no android device found")
+		} else {
+			err = fmt.Errorf("no android device found for serial %v", serial)
+		}
+		return nil, err
+	}
+	return deviceList, nil
 }
 
 type AndroidDevice struct {

hrp/pkg/uixt/android_test.go

@@ -324,7 +324,7 @@ func Test_getFreePort(t *testing.T) {
 }
 
 func TestDeviceList(t *testing.T) {
-	devices, err := DeviceList()
+	devices, err := GetAndroidDevices()
 	if err != nil {
 		t.Fatal(err)
 	}

hrp/pkg/uixt/ios_device.go

@@ -141,7 +141,7 @@ func WithIOSPcapOptions(options ...gidevice.PcapOption) IOSDeviceOption {
 	}
 }
 
-func IOSDevices(udid ...string) (devices []gidevice.Device, err error) {
+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,
@@ -168,6 +168,15 @@ func IOSDevices(udid ...string) (devices []gidevice.Device, err error) {
 		}
 	}
 
+	if len(deviceList) == 0 {
+		var err error
+		if udid == nil || (len(udid) == 1 && udid[0] == "") {
+			err = fmt.Errorf("no ios device found")
+		} else {
+			err = fmt.Errorf("no ios device found for udid %v", udid)
+		}
+		return nil, err
+	}
 	return deviceList, nil
 }
 
@@ -223,31 +232,27 @@ func NewIOSDevice(options ...IOSDeviceOption) (device *IOSDevice, err error) {
 		option(device)
 	}
 
-	deviceList, err := IOSDevices(device.UDID)
+	deviceList, err := GetIOSDevices(device.UDID)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(code.IOSDeviceConnectionError, err.Error())
 	}
 
-	for _, dev := range deviceList {
+	dev := deviceList[0]
-		udid := dev.Properties().SerialNumber
+	udid := dev.Properties().SerialNumber
-		device.UDID = udid
+	device.UDID = udid
-		device.d = dev
+	device.d = dev
 
-		// run xctest if XCTestBundleID is set
+	// run xctest if XCTestBundleID is set
-		if device.XCTestBundleID != "" {
+	if device.XCTestBundleID != "" {
-			_, err = device.RunXCTest(device.XCTestBundleID)
+		_, err = device.RunXCTest(device.XCTestBundleID)
-			if err != nil {
+		if err != nil {
-				log.Error().Err(err).Str("udid", udid).Msg("failed to init XCTest")
+			log.Error().Err(err).Str("udid", udid).Msg("failed to init XCTest")
-				continue
+			return
-			}
 		}
-
-		log.Info().Str("udid", device.UDID).Msg("select device")
-		return device, nil
 	}
 
-	return nil, errors.Wrap(code.IOSDeviceConnectionError,
+	log.Info().Str("udid", device.UDID).Msg("select ios device")
-		fmt.Sprintf("device %s not found", device.UDID))
+	return device, nil
 }
 
 type IOSDevice struct {