手机自动化测试：Appium源码分析之跟踪代码分析八

手机自动化测试：Appium源码分析之跟踪代码分析八

 

poptest是国内唯一一家培养测试开发工程师的培训机构，以学员能胜任自动化测试，性能测试，测试工具开发等工作为目标。如果对课程感兴趣，请大家咨询qq：908821478。

lib/server/helpers.js模块， 研究之前，我们不防猜测一下这个模块的作用，然后在研究完成时在总结里面重新定义一下这个模块的作用。我猜测这个模块的作用就是提供了一些独立的方法，作为一些工具方法供其他模块使用

加载其他模块

var _ = require("underscore")

, gridRegister = require('./grid-register.js')

, logger = require('./logger.js').get('appium')

, status = require('./status.js')

, io = require('socket.io')

, mkdirp = require('mkdirp')

, bytes = require('bytes')

, domain = require('domain')

, format = require('util').format

, Args = require("vargs").Constructor;

模块	意义
gridRegister	暂时不解释，等我学习到的时候再来解释
logger	本地模块，这个模块已经说烂了，简单的来说提供日志输出的
status	本地模块，请求返回码定义模块
socket.io	是跨平台，多种连接方式自动切换，做即时通讯方面的开发很方便
mkdirp	扩展模块，mkdir -p变异体，提供了创建目录的方法。
bytes	公共模块，转化字符串的bytes值到数字型(比如1TB转换成1099511627776)
domain	捕捉异步回调中出现的异常
util	核心模块，提供工具方法的模块
vargs	参数模块

函数

allowCrossDomain

说这个函数之前，我们先来看看CORS协议

module.exports.allowCrossDomain = function (req, res, next) {

safely(req, function () {

//定义了资源能被所有域使用

res.header('Access-Control-Allow-Origin', '*');

//指示存取資源所允許的方法，用來回應先導請求

res.header('Access-Control-Allow-Methods', 'GET,POST,PUT,OPTIONS,DELETE');

//指示那些HTTP header可以出現在真實請求，用於回應先導請求

res.header('Access-Control-Allow-Headers', 'origin, content-type, accept');

});

// need to respond 200 to OPTIONS

//如果接受的方法是OPTIONS方法，会返回200状态码

if ('OPTIONS' === req.method) {

safely(req, function () {

res.sendStatus(200);

});

} else {

//然后调用传入的next函数

next();

}

};

winstonStream

module.exports.winstonStream = {

write: function (msg) {

msg = msg.replace(/$\s*$/m, "");

msg = msg.replace(/\[[^\]]+\] /, "");

logger.log('debug', msg);

}

};

这个是函数么？不太清楚，我只能暂时理解function(msg)内部的东西(这里其实是一个json字符串，只包含一个write元素，它对应了一个处理函数) 
将msg经过2层过滤，去除一些特殊字符，然后打印出来

catchAllHandler

module.exports.catchAllHandler = function (e, req, res, next) {

safely(req, function () {

res.status(500).send({

status: status.codes.UnknownError.code

, value: "ERROR running Appium command: " + e.message

});

});

next(e);

};

这个方法其实就是简单的在函数调用前，添加一个函数。我们要执行的函数是next,而在next函数执行执行的函数是safely，这个safely我们在Appium源码分析(6)-responses模块解释过。其实就是调用了传入的嵌套函数，将response的状态码设置为500，然后发送一个json字符串。

checkArgs

checkArgs的函数分几部分分析

//检查args的有效参数

module.exports.checkArgs = function (parser, args) {

//定义一个二维数组

var exclusives = [

['noReset', 'fullReset']

, ['ipa', 'safari']

, ['app', 'safari']

, ['forceIphone', 'forceIpad']

, ['deviceName', 'defaultDevice']

];

//遍历二维数组exclusives,遍历的元素的设置为exSet，为一维数组

_.each(exclusives, function (exSet) {

var numFoundInArgs = 0;

//遍历一维数组，遍历的元素设置为opt

_.each(exSet, function (opt) {

if (_.has(args, opt) && args[opt]) {

//如果args含有exclusives定义的参数，numFoundInArgs加1

numFoundInArgs++;

}

});

if (numFoundInArgs > 1) {

//如果超过一个参数，打印错误信息

console.error(("You can't pass in more than one argument from the set " +

JSON.stringify(exSet) + ", since they are mutually exclusive").red);

process.exit(1);

}

});

checkValidPort

checkArgs嵌套函数：

//检查端口的有效性

var checkValidPort = function (port) {

//限定端口号范围为(0,6536)

if (port > 0 && port < 65536) return true;

//超出范围，报错，返回false

console.error("Port must be greater than 0 and less than 65536");

return false;

};

 

validations字符串

checkArgs函数中定义的json字符串，定义了一些变量和对应的处理函数:

var validations = {

port: checkValidPort

, callbackPort: checkValidPort

, bootstrapPort: checkValidPort

, selendroidPort: checkValidPort

, chromedriverPort: checkValidPort

, robotPort: checkValidPort

, backendRetries: function (r) { return r >= 0; }

};

checkValidPort函数我们刚讲过，就不多说了。json字符串的最后一个元素，指定了一个匿名函数，就是判断传入的参数是否非负。

检查非默认参数的有效性

//解析出非默认参数的参数，是一个json字符串

var nonDefaultArgs = getNonDefaultArgs(parser, args);

//遍历validations字符串，元素定义为map的key值为args,value值为validator

_.each(validations, function (validator, arg) {

//是否为非默认的参数

if (_.has(nonDefaultArgs, arg)) {

//检查是否通过

if (!validator(args[arg])) {

//不通过检查的打印错误信息并退出

console.error("Invalid argument for param " + arg + ": " + args[arg]);

process.exit(1);

}

}

});

到此checkArgs函数解释完毕，看得出来这个函数的工作很多，但是总结下来就是：检查一些非默认参数的有效性。

getNonDefaultArgs

这个函数是找到非默认参数的，参照物就是parser.js模块中定义的一系列参数，我们来先看看parser.js模块：

var args = [

[['--shell'], {

required: false

, defaultValue: null

, help: 'Enter REPL mode'

, nargs: 0

}],

[['--localizable-strings-dir'], {

required: false

, dest: 'localizableStringsDir'

, defaultValue: 'en.lproj'

, help: 'IOS only: the relative path of the dir where Localizable.strings file resides '

, example: "en.lproj"

}],

[['--app'], {

看一下就知道了，一会我们会用到这个。

//得到非默认的参数

var getNonDefaultArgs = function (parser, args) {

var nonDefaults = {};

//遍历parser中定义的参数，遍历的元素设置为rawArg

_.each(parser.rawArgs, function (rawArg) {

//取每一个rawArg的第二个元素的值，取得dest属性值

var arg = rawArg[1].dest;

if (args[arg] !== rawArg[1].defaultValue) {

//如果args相同字段对应的值不是我们默认值，将该值添加到nonDefaults,以属性值为下标。

nonDefaults[arg] = args[arg];

}

});

return nonDefaults;

};

上面的解释用到parser.js中json字符串args，该args是由多个json字符串组成，所以rawArg[1]取的就是其中遍历到的json字符串的值，比如第二次便利的时候，rawArg的值为：

[['--localizable-strings-dir'], {

required: false

, dest: 'localizableStringsDir'

, defaultValue: 'en.lproj'

, help: 'IOS only: the relative path of the dir where Localizable.strings file resides '

, example: "en.lproj"

}]

那么rawArg[1]指的就是：

{

required: false

, dest: 'localizableStringsDir'

, defaultValue: 'en.lproj'

, help: 'IOS only: the relative path of the dir where Localizable.strings file resides '

, example: "en.lproj"

}

那么rawArg[1].defaultValue的值自然就是en.lproj

noColorLogger

module.exports.noColorLogger = function (tokens, req, res) {

//得到response的Header部分，属性为Content-Length的值，将其转化为10进制的整数

var len = parseInt(res.getHeader('Content-Length'), 10);

//如果len不是整形,赋值为空字符串，如果是整形，在后面追加横岗(-)和字节数

len = isNaN(len) ? '' : ' - ' + bytes(len);

//组装字符串返回，该字符串有请求的方法，url地址，状态码，时间，毫秒单位，长度

return req.method + ' ' + req.originalUrl + ' ' +

res.statusCode + ' ' + (new Date() - req._startTime) + 'ms' + len;

};

configureServer

该方法在main.js模块中有调用。

module.exports.configureServer = function (rawConfig, appiumVer, appiumServer,

cb) {

//定义一个变量

var appiumRev;

//判断配置数据是否定义，未定义的话就直接报错，cb代表回调函数callback

if (!rawConfig) {

return cb(new Error('config data required'));

}

//定义一个空json字符串

var versionMismatches = {};

//定义一个数组excludedKeys并赋值

var excludedKeys = ["git-sha", "node_bin", "built"];

//遍历rawConfig

_.each(rawConfig, function (deviceConfig, key) {

//如果配置的元素中，版本的信息不等于appium的版本，而且属性的name值不在excludedKeys内，说明

//这个配置项是不匹配的，需要保存在versionMismatches中。

if (deviceConfig.version !== appiumVer && !_.contains(excludedKeys, key)) {

versionMismatches[key] = deviceConfig.version;

} else if (key === "git-sha") {

//如果上面的条件不满足，但是key值等于git-sha，将appiumRev的值设置为rawConfig中的git-sha指代的值

appiumRev = rawConfig['git-sha'];

}

});

//keys为遍历所有json字符串中的key值，组成一个数组，判断该数组的长度

if (_.keys(versionMismatches).length) {

//如果不匹配的配置项的个数大于0，输出一些错误的提示信息

logger.error("Got some configuration version mismatches. Appium is " +

"at " + appiumVer + ".");

_.each(versionMismatches, function (mismatchedVer, key) {

logger.error(key + " configured at " + mismatchedVer);

});

logger.error("Please re-run reset.sh or config");

return cb(new Error("Appium / config version mismatch"));

} else {

//如果配置都是正确的，调用registerConfig开始设置

appiumServer.registerConfig(rawConfig);

cb(null, appiumRev);

}

};

conditionallyPreLaunch

//预加载模式

module.exports.conditionallyPreLaunch = function (args, appiumServer, cb) {

//判断args.launch的属性是否为true

if (args.launch) {

logger.debug("Starting Appium in pre-launch mode");

//调用appium.js模块的预加载函数preLaunch，传入的参数为一个回调函数

appiumServer.preLaunch(function (err) {

if (err) {

logger.error("Could not pre-launch appium: " + err);

cb(err);

} else {

cb(null);

}

});

} else {

cb(null);

}

};

prepareTmpDir

//创建临时目录

module.exports.prepareTmpDir = function (args, cb) {

if (args.tmpDir === null) return cb();

//调用mkdirp模块的的方法创建目录

mkdirp(args.tmpDir, function (err) {

if (err) {

logger.error("Could not ensure tmp dir '" + args.tmpDir + "' exists");

logger.error(err);

}

cb(err);

});

};

startAlertSocket

var startAlertSocket = function (restServer, appiumServer) {

var alerts = io(restServer, {

'flash policy port': -1,

'logger': logger,

'log level': 1,

'polling duration': 10,

'transports': ['websocket', 'flashsocket']

});

//连接服务器，回调函数为连接后进行的处理

alerts.sockets.on("connection", function (socket) {

logger.debug("Client connected: " + (socket.id).toString());

//监听disconnect事件，当断开连接后，调用回调函数

socket.on('disconnect', function (data) {

logger.debug("Client disconnected: " + data);

});

});

// add web socket so we can emit events

//将该alerts时间添加到web socket中

appiumServer.attachSocket(alerts);

};

getDeprecatedArgs

 

//得到废弃的参数

var getDeprecatedArgs = function (parser, args) {

var deprecated = {};

//遍历parser中定义的参数，设置遍历的元素为rawArg

_.each(parser.rawArgs, function (rawArg) {

//获取元素的dest的值

var arg = rawArg[1].dest;

//如果dest指代的值存在，且rawArg[1]的属性deprecatedFor也存在

//将该值添加到json字符串deprecated中

if (args[arg] && rawArg[1].deprecatedFor) {

deprecated[rawArg[0]] = "use instead: " + rawArg[1].deprecatedFor;

}

});

return deprecated;

};

startListening

module.exports.startListening = function (server, args, parser, appiumVer, appiumRev, appiumServer, cb) {

//声明变量alreadyReturned并赋值为false

var alreadyReturned = false;

//监听某个url下的某个端口的消息，回调函数为连接成功后处理函数

server.listen(args.port, args.address, function () {

//欢迎信息，这些信息相信用过appium的人都见过，首先打印欢迎信息

var welcome = "Welcome to Appium v" + appiumVer;

//如果git-sha的赋值给了appiumRev，就将其追加到欢迎信息中

if (appiumRev) {

welcome += " (REV " + appiumRev + ")";

}

//打印welcome信息

logger.info(welcome);

var logMessage = "Appium REST http interface listener started on " +

args.address + ":" + args.port;

//打印ip地址和端口号

logger.info(logMessage);

//调用startAlertSocket启动连接socket

startAlertSocket(server, appiumServer);

if (args.nodeconfig !== null) {

//如果node配置信息不为null，那么就配置node信息

gridRegister.registerNode(args.nodeconfig, args.address, args.port);

}

var showArgs = getNonDefaultArgs(parser, args);

if (_.size(showArgs)) {

//如果非默认参数的个数大于0，需要打印出来

logger.debug("Non-default server args: " + JSON.stringify(showArgs));

}

var deprecatedArgs = getDeprecatedArgs(parser, args);

if (_.size(deprecatedArgs)) {

//如果有废弃的参数，也需要打印出来

logger.warn("Deprecated server args: " + JSON.stringify(deprecatedArgs));

}

//这个应该很熟悉，我们经常启动的时候就能看见这个,输出log的等级，大于等于这个等级的log才会输出

logger.info('Console LogLevel: ' + logger.transports.console.level);

//文件log的等级，大于等于这个等级的信息才会保存

if (logger.transports.file) {

logger.info('File LogLevel: ' + logger.transports.file.level);

}

});

//监听error事件

server.on('error', function (err) {

if (err.code === 'EADDRNOTAVAIL') {

logger.error("Couldn't start Appium REST http interface listener. Requested address is not available.");

} else {

logger.error("Couldn't start Appium REST http interface listener. Requested port is already in use. Please make sure there's no other instance of Appium running already.");

}

if (!alreadyReturned) {

alreadyReturned = true;

cb(err);

}

});

//设置超时连接时间为10分钟

server.on('connection', function (socket) {

socket.setTimeout(600 * 1000); // 10 minute timeout

});

//延迟任务，在1秒后执行函数

setTimeout(function () {

if (!alreadyReturned) {

alreadyReturned = true;

cb(null);

}

}, 1000);

};

调用该方法，一般会打印如下信息：

nfo: Welcome to Appium v1.3.7 (REV 72fbfaa116d3d9f6a862600ee99cf02f6d0e2182)

info: Appium REST http interface listener started on 0.0.0.0:4723

info: [debug] Non-default server args: {"platformName":"Android","platformVersion":"4.4","automationName":"Appium","defaultCommandTimeout":7200}

info: Console LogLevel: debug

compile

function compile(fmt) {

fmt = fmt.replace(/"/g, '\\"');

var js = '  return "' + fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g,

function (_, name, arg) {

return '"\n    + (tokens["' + name + '"](req, res, "' + arg + '") || "-") + "';

}) + '";';

// jshint evil:true

return new Function('tokens, req, res', js);

}

这个函数是设置打印的字符串格式

requestStartLoggingFormat

//一次请求的开始，输出的log格式，格式类似 info: --> GET /wd/hub/status {}

module.exports.requestStartLoggingFormat = compile('-->'.white + ' ' + ':method'.white + ' ' +

  ':url'.white);

requestEndLoggingFormat

//一次请求的结束，输出log格式，格式类似：info: <-- GET /wd/hub/status 200 4.102 ms - 104 

//{"status":0,"value":{"build":{"version":"1.3.7","revision":"72fbfaa116d3d9f6a862600ee99cf02f6d0e2182"}}}

module.exports.requestEndLoggingFormat = function (tokens, req, res) {

  var status = res.statusCode;

  var statusStr = ':status';

  //状态码大于500的话，状态码为红色

  if (status >= 500) statusStr = statusStr.red;

  //状态码大于400小于500，状态码为黄色

  else if (status >= 400) statusStr = statusStr.yellow;

  //状态码大于300小于400，状态码为蓝绿色

  else if (status >= 300) statusStr = statusStr.cyan;

  //小于300，状态码为绿色

  else statusStr = statusStr.green;

  var fn = compile('<-- :method :url '.white + statusStr +

    ' :response-time ms - :res[content-length]'.grey);

  return fn(tokens, req, res);

};

getRequestContext

//得到请求的内容

function getRequestContext(req) {

//如果req未定义，直接返回空字符串

if (!req) return '';

var data = '';

try {

//截取req的body部分，索引0到200的字符串

if (req.body) data = JSON.stringify(req.body).substring(0, 200);

} catch (ign) {}

return format('context: [%s %s %s]', req.method, req.url, data).replace(/ ]$/, '');

}

safely

var safely = function () {

//获取传递进来的参数

var args = new (Args)(arguments);

//获得第一个参数

var req = args.all[0];

//回调函数

var fn = args.callback;

try {

//调用回调函数

fn();

} catch (err) {

logger.error('Unexpected error:', err.stack, getRequestContext(req));

}

};

module.exports.safely = safely;

domainMiddleware

module.exports.domainMiddleware = function () {

return function (req, res, next) {

//创建一个域记录

var reqDomain = domain.create();

//将req和res添加到域管理

reqDomain.add(req);

reqDomain.add(res);

//res监听close事件

res.on('close', function () {

//延迟事件，5秒后关闭域

setTimeout(function () {

reqDomain.dispose();

}, 5000);

});

//reqDomain添加error事件

reqDomain.on('error', function (err) {

logger.error('Unhandled error:', err.stack, getRequestContext(req));

});

//执行next函数

reqDomain.run(next);

};

};