手机自动化测试：Appium源码分析之跟踪代码分析六
poptest是国内唯一一家培养测试开发工程师的培训机构，以学员能胜任自动化测试，性能测试，测试工具开发等工作为目标。poptest推出手机自动化测试的课程，讲解appuim的实际应用，培训全程用商业项目， 大家可以加qq群进行交流：195983133
加载模块
var logger = require(‘./logger.js’).get(‘appium’)
, status = require(‘./status.js’)
, _ = require(‘underscore’)
, safely = require(‘./helpers’).safely;
加载了4个模块，3个本地模块(logger,status,helpers)和一个核心工具模块(underscore)。本地模块我们后续再讲解，这个工具模块是做什么用的，我找到一篇文章讲解这个underscore,从这篇文章可以了解到这个模块主要提供了一些常用的函数，大概80个。
7个函数
reponses模块中包含7个函数，下面我们一步一步解释
getSessionId函数
//得到session的id号，每一个session都有一个独特的id用来标识
var getSessionId = function (req, response) {
//判断传递过来的参数response是否初始化，如果已经初始化，sessionId的值就赋值为response的属性sessionId的值
//否则赋值为undefined
var sessionId = (typeof response === ‘undefined’) ? undefined : response.sessionId;
//经过上面的赋值后，如果sessionId的值为undefined，那么就要进一步处理
if (typeof sessionId === “undefined”) {
if (req.appium) {
//如果req.appium初始化过，就将appium中的属性sessionId赋值给当前变量sessionId
//需要注意的是后面的||null写法，如果req.appium.sessionId是没有定义的，那么会走到||后面，意思也是
//给sessionId定义为null，如果不加||null，会发生什么呢？（sessionId=undefined）…
sessionId = req.appium.sessionId || null;
} else {
//如果req.appium没有初始化，那么就直接将sessionId置为空
sessionId = null;
}
}
//因为我们要求返回的sessionId是一个字符串，那么我就要判断该类型是否正确，如果不正确，也需要置为null值
if (typeof sessionId !== “string” && sessionId !== null) {
sessionId = null;
}
return sessionId;
};
notImplementedInThisContext
//当我们调用的方法，并不存在的时候，会调用该方法，该方法一般是在设备端，执行查找或对某一个控件进行操作的。
var notImplementedInThisContext = function (req, res) {
//首先打印提示信息
logger.debug(“Responding to client that a method is not implemented ” +
“in this context”);
safely(req, function () {
//状态设置为501,并返回一个json字符串
res.status(501).send({
status: status.codes.UnknownError.code
, sessionId: getSessionId(req)
, value: {
//提示信息消息体
message: “Not implemented in this context, try switching ” +
“into or out of a web view”
}
});
});
};
上面的函数体内有2个地方需要理解：safely()和res.status(501).send()
|
函数 |
意义 |
|
safely |
helpers.js模块中safely方法 |
|
res.status(501).send |
将response状态设置为501，然后发送一个消息 |
下面是safely方法的源码,也很简单，就是调用了嵌套的回调函数。
// Mainly used to wrap http response methods, or for cases where errors
// perdure the domain
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));
}
};
respondError
//返回错误信息
var respondError = exports.respondError = function (req, res, statusObj, value) {
//设置错误信息的内容和状态码，因为message要求是字符串类型，code是整形类型
var code = 1, message = “An unknown error occurred”;
var newValue = value;
if (typeof statusObj === “string”) {
message = statusObj;
} else if (typeof statusObj === “undefined”) {
message = “undefined status object”;
} else if (typeof statusObj === “number”) {
code = statusObj;
message = status.getSummaryByCode(code);
} else if (typeof statusObj.code !== “undefined”) {
code = statusObj.code;
message = statusObj.summary;
} else if (typeof statusObj.message !== “undefined”) {
message = statusObj.message;
}
//如果value的值是一个对象类型的值，需要从这个对象中解析出message属性
//然后进行拼接组成一个json字符串，赋值给newValue,如果不是一个对象类型的值
//直接组装成json字符串
if (typeof newValue === “object”) {
if (newValue !== null && _.has(value, “message”)) {
// make sure this doesn’t get obliterated
value.origValue = value.message;
message += ” (Original error: ” + value.message + “)”;
}
newValue = _.extend({message: message}, value);
} else {
newValue = {message: message, origValue: value};
}
//拼接返回信息json字符串对象reponse
var response = {status: code, value: newValue};
//获取sessionId
response.sessionId = getSessionId(req, response);
logger.debug(“Responding to client with error: ” + JSON.stringify(response));
//调用helpers.js模块的safely函数，就是调用里面的嵌套函数
safely(req, function () {
res.status(500).send(response);
});
};
respondSuccess
var respondSuccess = exports.respondSuccess = function (req, res, value, sid) {
var response = {status: status.codes.Success.code, value: value};
response.sessionId = getSessionId(req, response) || sid;
if (typeof response.value === “undefined”) {
response.value = ”;
}
var printResponse = _.clone(response);
var maxLen = 1000;
if (printResponse.value !== null &&
typeof printResponse.value.length !== “undefined” &&
printResponse.value.length > maxLen) {
printResponse.value = printResponse.value.slice(0, maxLen) + “…”;
}
res.jsonResp = JSON.stringify(printResponse);
logger.debug(“Responding to client with success: ” + res.jsonResp);
safely(req, function () {
res.status(200).send(response);
});
};
这个函数我就不解释了，因为大致的方式都是一样的，都是先解析出打印的消息体，然后发送出去，只是这里面的response状态是200，因为是成功的。该方法调用的log信息，我们会经常见到。
getResponseHandler
exports.getResponseHandler = function (req, res) {
//直接返回匿名函数
return function (err, response) {
//先判断response是否已经初始化，或者是否初始化为空
if (typeof response === “undefined” || response === null) {
//设置为空的json字符串
response = {};
}
//判断错误的信息，符合如下条件的，直接抛出异常
if (err !== null && typeof err !== “undefined” && typeof err.status !== ‘undefined’ && typeof err.value !== ‘undefined’) {
throw new Error(“Looks like you passed in a response object as the ” +
“first param to getResponseHandler. Err is always the ” +
“first param! Fix your codes!”);
} else if (err !== null && typeof err !== “undefined”) {
if (typeof err.name !== ‘undefined’) {
if (err.name === ‘NotImplementedError’) {
//如果错误的name值为NotImplementedError,就调用notImplementedInThisContext函数
notImplementedInThisContext(req, res);
} else if (err.name === “NotYetImplementedError”) {
//如果错误的name值为NotYetImplementedError,就调用notYetImplemented函数
notYetImplemented(req, res);
} else {
//其他类型都调用respondError
respondError(req, res, status.codes.UnknownError.code, err);
}
} else {
var value = response.value;
if (typeof value === “undefined”) {
value = ”;
}
//如果错误类型name属性值为undefined,我们调用respondError的时候传入的参数为value值
respondError(req, res, err.message, value);
}
} else {
//如果错误信息为空或者未定义，我们需要根据状态码的不同，调用不同函数处理
if (response.status === 0) {
respondSuccess(req, res, response.value, response.sessionId);
} else {
respondError(req, res, response.status, response.value);
}
}
};
};
终于到了我们真正要解释的函数了-getResponseHandler，从我上面的解释可以看出来，该函数是一个控制类的函数，所有的调用经过该函数处理后，会根据传入参数的不同，调用不同的函数，所以这个函数名字取为handler，以为回复处理器。
checkMissingParams
exports.checkMissingParams = function (req, res, params, strict) {
//如果strict未定义，设置为false,说明strict为boolean类型的值
if (typeof strict === “undefined”) {
strict = false;
}
var missingParamNames = [];
//迭代params所有的元素，获取所有没有定义的或者值与strict相反的参数，添加到missingParamNames数组中
_.each(params, function (param, paramName) {
if (typeof param === “undefined” || (strict && !param)) {
missingParamNames.push(paramName);
}
});
if (missingParamNames.length > 0) {
//将数组转化为json字符串
var missingList = JSON.stringify(missingParamNames);
logger.debug(“Missing params for request: ” + missingList);
//response的状态为400，消息体为上面的json字符串的
safely(req, function () {
res.status(400).send(“Missing parameters: ” + missingList);
});
return false;
} else {
return true;
}
};
上面的函数是找到为定义的参数或者为null的参数
notYetImplemented
//在getResponseHandler函数中我们看到当err.name为NotYetImplementedError时，会调用该函数
var notYetImplemented = exports.notYetImplemented = function (req, res) {
//与notImplementedInThisContext类似,都是将response的状态设置为501，然后消息体不同
logger.debug(“Responding to client that a method is not implemented”);
safely(req, function () {
res.status(501).send({
status: status.codes.UnknownError.code
, sessionId: getSessionId(req)
, value: {
message: “Not yet implemented. ” +
“Please help us: http://appium.io/get-involved.html”
}
});
});
};
