高阶测试：Appium集成openSTF实现多设备并发执行用例

lsekfe

一、应用场景：
　　你是否有这样的困惑：通过appium+testng已经写好一个个移动端自动化用例了，单个用例运行也没有什么问题，但是真实的企业应用场景是筛选一批合适的用例同时运行，无人值守，那下面这个案例将是一个本人已实践过的方案，希望能带给你相关的思考。

　　二、本文案例环境配置：
　　搭建好openSTF服务，并连接至少2台移动设备(或模拟器)。
　　http://www.360doc.com/showweb/0/0/983537700.aspx
　　编写appium+testng安卓端自动化用例。
　　安装nodejs并通过nodejs安装appium。
　　http://www.360doc.com/content/21/0528/18/8189294_979429344.shtml
　　基本思路图：

　注：
　　本文仅作为一个思路引导，真正的实践其实是根据公司现有的自动化成果来做调整的，读者可将里面对你有用的东西引入进你自己的自动化中。
　　接下来将根据上述图示来写代码，本文的重点是与openStf相关的内容，关于appium自动化用例如何编写，appium如何批量运行，怎样介入mq等不在本文范围。

　　三、appium并发执行的2种思路
　　3.1、 hub--node的方式(即selenium grid + appium node)
　　如下图，它的grid其实就用的是selenium的grid，他们是通用的，只是web端你需要将浏览器node关联至grid，而移动端与grid关联的就是一个个appium server，每个appium server再去连接一台移动设备。
　　此种方式需要在用例运行前即把每台移动设备与appium server连接好，然后用例运行时grid即去将用例分发至每个appium node上去执行。
　　我们当前没有采用该种方式，考虑到移动设备需要充分利用，使用该种方式有局限性。---从当前了解到的知识来看，后续或许能找到相关解决方案。

　　3.2、动态启appium服务(随时用随时启，只要有空闲移动设备)
　　这是由appium本身的工作机制决定，因为一个appium服务，只能与一台移动设备通信，而要实现并发，那就需要多启几个服务，且每个服务都要连接一台手机。
　　而在本案例中即通过在用例执行时去动态启动appium服务，并连接到空闲移动设备。

　　四、代码实现
　　1)启动appium server

1. public class AppiumServer {
   
2. private static AppiumServiceBuilder appiumServicebuilder;
   
3. private static AppiumDriverLocalService appiumService;
   
4. public static URL getAppiumUrl (){
   
5.     logger.info("获取Ip:"+appiumService.getUrl().toString());
   
6.     return appiumService.getUrl();
   
7. }
   
8. public static void startServer(){
   
9.     //启动appium服务
   
10.     appiumServicebuilder = new AppiumServiceBuilder();
    
11.     appiumServicebuilder.withIPAddress("127.0.0.1");//此处ip无法动态，手机必须连接在服务启动的电脑
    
12.     int port = Integer.parseInt("47"+ RandomUtil.nextInt(89));
    
13.     logger.info("Random appium server port is:"+port);
    
14.     if (!checkAppiumServerIsRunning(port)){
    
15.         appiumServicebuilder.usingPort(port);//需要改成动态的
    
16.     }
    
17. 
    
18.     appiumServicebuilder.withArgument(GeneralServerFlag.SESSION_OVERRIDE);
    
19.     appiumServicebuilder.withArgument(GeneralServerFlag.LOG_LEVEL,"error");//暂时不知道是哪里的日志级别
    
20.     //appiumService = AppiumDriverLocalService.buildDefaultService();
    
21.     appiumService = AppiumDriverLocalService.buildService(appiumServicebuilder);
    
22.     appiumService.start();
    
23. }
    
24. }

复制代码

2)启动appium driver

1. public class MyAndroidKeyMobileDriver{
   
2. /*
   
3. * 启动driver
   
4. */
   
5. public static WebDriver getDriver(ITestContext context) {
   
6.     WebDriver driver = null;
   
7.     DesiredCapabilities desiredCapabilities = null;
   
8.     try {
   
9.         desiredCapabilities = BaseDriven.setAndroidCapabilities(context);
   
10.         //新增的代码
    
11.         driver = new AndroidDriver<>(AppiumServer.getAppiumUrl(), desiredCapabilities);
    
12.         DriverCache.set(driver);
    
13.         driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
    
14. 
    
15.         logger.info("appium android 成功启动 APP Package [ " +
    
16. 
    
17. desiredCapabilities.getCapability(AndroidMobileCapabilityType.APP_PACKAGE) + " ]。");
    
18.     }catch ( WebDriverException e ) {
    
19.         if (e.getMessage().contains("Connection refused: ")) {
    
20.             logger.error("Appium Desktop 服务器未启动，请检查，谢谢。");
    
21.         }
    
22.         if (e.getMessage().contains("not find app package")) {
    
23.             assert desiredCapabilities != null;
    
24.             logger.error("Android app【 " + desiredCapabilities.getCapability
    
25. 
    
26. (AndroidMobileCapabilityType.APP_PACKAGE) + " ] 不存在。");
    
27.         }
    
28.         logger.error("App启动异常：", e);
    
29.     }
    
30.     return driver;
    
31. }
    
32. }

复制代码

3)通过stf api操作设备

　　注：stf提供了关于操作所挂载的设备相关接口，只要把stf服务启动起来即可访问。

1. /*
   
2. *   获取所有设备
   
3. */
   
4. public static List<DeviceEntity> getAllDevices(){
   
5.     Map stfHeaderMap = new HashMap();
   
6.     Map paramMap = new HashMap();
   
7.     stfHeaderMap.put("Authorization","Bearer "+ACCESS_TOKEN);
   
8.     String response = httpClientAdaptor.doGet(STF_SERVICE_URL + "devices",stfHeaderMap,paramMap);//查询所有的设备
   
9.     Map maps = JsonUtil.toObject(response, Map.class); // json转换为Map
   
10.     String devices = String.valueOf(maps.get("devices")); // 获取设备列表，是一个json数组
    
11.     System.out.println("所有的设备信息："+devices);
    
12. 
    
13.     //将json数组转化为
    
14.     List<DeviceEntity> deviceList = new ArrayList<>();
    
15.     JSONArray array = JsonUtil.toJSONArray(devices);
    
16.     for (int i = 0;i<array.size();i++){
    
17.         DeviceEntity deviceEntity = new DeviceEntity();
    
18.         JSONObject obj = (JSONObject) array.get(i);
    
19.         deviceEntity.setSerial(obj.getString("serial"));
    
20.         deviceEntity.setPlatform(obj.getString("platform"));
    
21.         deviceEntity.setVersion(obj.getString("version"));
    
22.         deviceEntity.setRemoteConnectUrl(obj.getString("remoteConnectUrl"));
    
23.         deviceEntity.setUsing(Boolean.parseBoolean(obj.getString("using")));
    
24.         deviceEntity.setReady(Boolean.parseBoolean(obj.getString("ready")));
    
25.         deviceEntity.setPresent(Boolean.parseBoolean(obj.getString("present")));
    
26. 
    
27.         String providerJson = obj.getString("provider");
    
28.         Map providerMaps = JsonUtil.toObject(providerJson, Map.class);
    
29.         String providerName = (String) providerMaps.get("name");
    
30.         deviceEntity.setProvider(providerName);
    
31.         deviceList.add(deviceEntity);
    
32.     }
    
33.     System.out.println("设备个数："+deviceList.size());
    
34.     return deviceList;
    
35. }
    
36. /*
    
37. *   查找空闲设备并锁定
    
38. */
    
39. public static String connectFreeDevice(String slaveMachine){
    
40.     String currentConnectedDevice = null;
    
41.     List<DeviceEntity> deviceList = getAllDevices();
    
42.     for (Iterator itr = deviceList.iterator(); itr.hasNext();) {
    
43.         DeviceEntity device = (DeviceEntity) itr.next();
    
44.         //获取对应编译机上挂载的手机设备
    
45.         if (device.getProvider().contains(slaveMachine)){
    
46.             if (!device.isPresent() || !device.isReady() || device.isUsing()){
    
47.                 //logger.error("device is in use!");
    
48.                 continue;
    
49.             }
    
50.             //找到空闲即申请使用
    
51.             currentConnectedDevice = device.getSerial();
    
52.             addDeviceToUser(currentConnectedDevice);
    
53.             logger.info("Find free device："+currentConnectedDevice);
    
54.             break;
    
55.         }
    
56.     }
    
57.     return currentConnectedDevice;
    
58. }
    
59. /*
    
60. *   锁定设备，标识被某个stf的账户占用
    
61. */
    
62. private static boolean addDeviceToUser(String serial){
    
63.     String reqJson = "{\"serial\": \""+serial+"\"}";
    
64.     Map stfHeaderMap = new HashMap();
    
65.     Map paramMap = new HashMap();
    
66.     stfHeaderMap.put("Authorization","Bearer "+ACCESS_TOKEN);
    
67.     stfHeaderMap.put("Content-Type","application/json; charset=utf-8");
    
68.     String response = httpClientAdaptor.doPost(STF_SERVICE_URL + "user/devices",stfHeaderMap,reqJson);
    
69.     logger.info("mq 端锁定设备响应消息:"+response);
    
70.     Map maps = JsonUtil.toObject(response, Map.class); // json转换为Map
    
71.     if (!Boolean.parseBoolean(String.valueOf(maps.get("success")))) {
    
72.         logger.error("Device not found");
    
73.         return false;
    
74.     }
    
75.     logger.info("The device ["+serial+"]is locked successfully");
    
76.     return true;
    
77. }
    
78. /*
    
79. * 释放设备(用例用完以后，将该设备重新置为空闲)
    
80. */
    
81. public static void releaseDevice(String serial) {
    
82.     Map paramMap = new HashMap();
    
83.     Map stfHeaderMap = new HashMap();
    
84.     stfHeaderMap.put("Authorization","Bearer "+stfService.getAuthToken());
    
85.     String response = httpClientAdaptor.doDelete(stfService.getStfUrl() + "user/devices/"+serial,stfHeaderMap,"");
    
86.     logger.info("释放设备接口返回信息："+response);
    
87. }

复制代码

4)用例层调用上述方法

package cn.study.testapi.base.support;

import cn.study.testapi.base.enums.DrivenEnum;
import cn.study.testapi.base.load.InitLoadNew;
import cn.study.testapi.core.appium.server.AppiumServer;
import cn.study.testapi.core.driver.driven.factory.KeyDriverFactory;
import cn.study.testapi.core.driver.keydriver.AndroidKeyDriver;
import cn.study.testapi.core.openstf.DeviceApi;
import cn.study.testapi.utils.*;
import cn.study.testapi.core.keyaction.AndroidKeyAction;
import cn.study.testapi.core.entity.ComponentStep;
import org.apache.log4j.Logger;
import org.testng.ITestContext;
import org.testng.annotations.*;
import java.util.List;

public class AndroidKeywordTest extends BaseKeyTest {
    protected static Logger logger = Logger.getLogger(AndroidKeywordTest.class);
    protected AndroidKeyDriver driver = null;
    //在testng suit之前启动appium server
    @Parameters({"deviceSerial"})
    @BeforeSuite(alwaysRun = true)
    public void setUp(@Optional("deviceSerial") String deviceSerial, ITestContext context) {
        InitLoadNew initLoadNew = new InitLoadNew(odinEnv, taskId);
        // 初始化接口返回result
        setCaseStepList(initLoadNew.getCaseStepList());
        AppiumServer.startServer();//启动appium server
        driver = MyAndroidKeyMobileDriver.getDriver(context); // 启动android app，根据自己的项目结构去设计此处获取driver的方式
    }

    @Test(alwaysRun = true, dataProvider = "keyword")
    public void testCaseStep(List<ComponentStep> data) {
        //执行你的用例
    }
    //aftersuit执行的动作，此处传一个【设备序列】参数，指明要释放的设备
    @Parameters({"deviceSerial"})
    @AfterSuite(alwaysRun = true)
    public void tearDown(@Optional("deviceSerial") String deviceSerial) {
        logger.info("========= tearDown ========");
        DeviceApi.releaseDevice(deviceSerial);//释放移动设备
        AppiumServer.stopAppiumServer();//用例执行完后停掉服务
        JdbcUtil.close();
        TempFileUtil.deleteOnExit();
        driver.quit();
    }

}

代码写完以后，你就可以尝试并行执行多条android端自动化用例看看效果啦。