XiaoMo/anyproxy
1
0
Fork 0
mirror of https://github.com/alibaba/anyproxy.git synced 2025-08-04 21:39:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

introduce jest and travis-ci (#541)

Browse Source 
introduce jest and travis-ci
This commit is contained in:
Otto Mao
2020-01-21 10:59:14 +08:00
committed by xiaofeng.mxf
parent 3deacd2387
commit 2516ea2d57
90 changed files with 865 additions and 3379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
test/spec_rule/no_rule_big_response_spec.js
View File

@@ -1,42 +0,0 @@
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
const { printLog } = require('../util/CommonUtil.js');
const spawn = require('child_process').spawn;
const Server = require('../server/server.js');
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
describe('Test request with big body', () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 200000;
printLog('Start server for no_rule_big_response');
serverInstance = new Server();
proxyServer = ProxyServerUtil.defaultProxyServer();
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Closed server for no_rule_spec');
});
it('should successfully get file', (done) => {
const isWin = /^win/.test(process.platform);
if (isWin) {
done();
} else {
const curl = spawn('curl', ['http://localhost:3000/big_response', '--proxy', 'http://127.0.0.1:8001', '-o', '/dev/null']);
curl.on('close', (code) => {
expect(code).toEqual(0);
done();
});
}
});
});

427
test/spec_rule/no_rule_spec.js
View File

@@ -1,427 +0,0 @@
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
const path = require('path');
const fs = require('fs');
const Server = require('../server/server.js');
const
{
proxyGet,
proxyPost,
directGet,
directPost,
directUpload,
proxyUpload,
generateUrl,
proxyPut,
directPut,
proxyDelete,
directDelete,
directHead,
proxyHead,
directOptions,
proxyOptions,
proxyPutUpload,
directPutUpload
} = require('../util/HttpUtil.js');
const { CommonRequestHeader } = require('../data/headers.js');
const { isCommonResHeaderEqual, isCommonReqEqual, printLog } = require('../util/CommonUtil.js');
const streamEqual = require('stream-equal');
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
testRequest('http');
testRequest('https');
testRequest('http', false);
testRequest('https', false);
// Test suites for http and https request
function testRequest(protocol = 'http', needWeb = true) {
function constructUrl(urlPath) {
return generateUrl(protocol, urlPath);
}
describe('Test request without proxy rules in protocol ' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 200000;
printLog('Start server for no_rule_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.defaultProxyServer(needWeb);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Closed server for no_rule_spec');
});
it('Get should work as direct without proxy rules', (done) => {
const url = constructUrl('/test');
const getParam = {
param: 'nothing'
};
proxyGet(url, getParam, CommonRequestHeader).then((proxyRes) => {
directGet(url, getParam, CommonRequestHeader).then(directRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
expect(proxyRes.statusCode).toEqual(directRes.statusCode);
expect(directRes.body).toEqual(proxyRes.body);
done();
}, error => {
console.error('error happend in direct get:', error);
done.fail('error happend in direct get');
});
}, error => {
console.log('error happened in proxy get:', error);
done.fail('error happend in proxy get');
});
});
it('Post should work as direct without proxy rules', (done) => {
const url = constructUrl('/test/getuser');
const param = {
param: 'postnothing'
};
proxyPost(url, param, CommonRequestHeader).then(proxyRes => {
directPost(url, param, CommonRequestHeader).then(directRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(proxyRes.statusCode).toEqual(directRes.statusCode);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error in direct post:', error);
done.fail('error happend in direct post');
});
}, error => {
console.log('error happened in proxy post,', error);
done.fail('error happend in proxy post');
});
});
it('PUT should work as direct without proxy rules', done => {
const url = constructUrl('/test/put');
const param = {
param: 'putsomething'
};
proxyPut(url, param, CommonRequestHeader).then(proxyRes => {
directPut(url, param, CommonRequestHeader).then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error happened in direct put', error);
done.fail('error happened in direct put');
});
}, error => {
console.error('error happened in proxy put', error);
done.fail('error happened in proxy put');
});
});
it('DELETE rquest should work as direct without proxy rules', (done) => {
const url = constructUrl('/test/delete/123456');
proxyDelete(url, {}, CommonRequestHeader).then(proxyRes => {
directDelete(url, {}, CommonRequestHeader).then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error happened in direct delete :', error);
done.fail('error happened in direct delete');
});
}, error => {
console.error('error happened in proxy delete :', error);
done.fail('error happened in proxy delete');
});
});
it('HEAD request should work as direct without proxy rules', (done) => {
const url = constructUrl('/test/head');
proxyHead(url, CommonRequestHeader)
.then(proxyRes => {
directHead(url, CommonRequestHeader)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('');
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error happened in direct head request:', error);
done.fail('error happened in direct head request');
});
}, error => {
console.error('error happened in proxy head request:', error);
done.fail('error happened in proxy head request');
});
});
it('OPTIONS request should work as direct without proxy rules', (done) => {
const url = constructUrl('/test/options');
proxyOptions(url, CommonRequestHeader)
.then(proxyRes => {
directOptions(url, CommonRequestHeader)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('could_be_empty');
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error happened in direct options request:', error);
done.fail('error happened in direct options request');
});
}, error => {
console.error('error happened in proxy options request:', error);
done.fail('error happened in proxy options request');
});
});
it('304 should work as direct without proxy rules', (done) => {
const url = constructUrl('/test/response/304');
proxyGet(url, CommonRequestHeader)
.then(proxyRes => {
directGet(url, CommonRequestHeader)
.then(directRes => {
expect(directRes.statusCode).toEqual(304);
expect(directRes.body).toEqual('');
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(directRes.body).toEqual(proxyRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error happened in direct 304 request:', error);
done.fail('error happened in direct 304 request');
});
}, error => {
console.error('error happened in proxy 304 request:', error);
done.fail('error happened in proxy 304 request');
});
})
describe('Response code should be honored as direct without proxy rules', () => {
[301, 302, 303].forEach(code => {
testRedirect(code);
});
function testRedirect(redirectCode) {
it(`${redirectCode} response should work as direct without proxy rules`, (done) => {
const url = constructUrl(`/test/response/${redirectCode}`);
proxyGet(url)
.then(proxyRes => {
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(redirectCode);
expect(directRes.headers.location).toEqual(proxyRes.headers.location);
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(directRes.headers.location).toEqual('/test');
done();
}).catch(error => {
console.log(`error happened in direct ${redirectCode}:`, error);
done.fail(`error happened in direct ${redirectCode}`);
});
}).catch(error => {
console.log(`error happened in proxy ${redirectCode}:`, error);
done.fail(`error happened in proxy ${redirectCode}`);
});
});
}
});
describe('Test file download ', () => {
const testArray = [
{
url: constructUrl('/test/download/png'),
type: 'png',
contentType: 'image/png'
},
{
url: constructUrl('/test/download/webp'),
type: 'WEBP',
contentType: 'image/webp'
},
{
url: constructUrl('/test/download/json'),
type: 'JSON',
contentType: 'application/json; charset=utf-8'
},
{
url: constructUrl('/test/download/css'),
type: 'CSS',
contentType: 'text/css; charset=utf-8'
},
{
url: constructUrl('/test/download/ttf'),
type: 'TTF',
contentType: 'application/x-font-ttf'
},
{
url: constructUrl('/test/download/eot'),
type: 'EOT',
contentType: 'application/vnd.ms-fontobject'
},
{
url: constructUrl('/test/download/svg'),
type: 'SVG',
contentType: 'image/svg+xml'
},
{
url: constructUrl('/test/download/woff'),
type: 'WOFF',
contentType: 'application/font-woff'
},
{
url: constructUrl('/test/download/woff2'),
type: 'WOFF2',
contentType: 'application/font-woff2'
}
];
testArray.forEach(item => {
testFileDownload(item.url, item.type, item.contentType);
});
// 封装测试文件下载的测试工具类
function testFileDownload(url, filetype, contentType) {
const describe = `${filetype} file download without rules should be work as direct download`;
const param = {};
it(describe, (done) => {
proxyGet(url, param).then(proxyRes => {
directGet(url, param).then(directRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(proxyRes.statusCode).toEqual(directRes.statusCode);
expect(proxyRes.body).toEqual(directRes.body);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}, error => {
console.error('error in direct get :', filetype, error);
done.fail(`error happend in direct get ${filetype}`);
});
}, error => {
console.error('error in proxy get :', filetype, error);
done.fail(`error happend in proxy get ${filetype}`);
});
});
}
});
describe('Test file upload', () => {
const formParams = {
param1: 'param_1',
param2: 'param2'
};
it('POST upload should be working', (done) => {
const url = constructUrl('/test/upload/png');
const filePath = path.resolve(__dirname, '../data/test.png');
proxyUpload(url, filePath, formParams)
.then(proxyRes => {
directUpload(url, filePath, formParams)
.then((directRes) => {
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
assertReponse(proxyRes, directRes, filePath, done);
}, error => {
console.error('error in direct upload:', error);
done.fail('error in direct upload');
});
}, error => {
console.error('error in proxy upload:', error);
done.fail('error in proxy upload:');
});
});
it('PUT upload should be working', (done) => {
const url = constructUrl('/test/upload/putpng');
const filePath = path.resolve(__dirname, '../data/test.png');
proxyPutUpload(url, filePath, formParams)
.then(proxyRes => {
directPutUpload(url, filePath, formParams)
.then((directRes) => {
expect(isCommonResHeaderEqual(directRes.headers, proxyRes.headers, url)).toBe(true);
assertReponse(proxyRes, directRes, filePath, done);
}, error => {
console.error('error in direct upload:', error);
done.fail('error in direct upload');
});
}, error => {
console.error('error in proxy upload:', error);
done.fail('error in proxy upload:');
});
});
function assertReponse(proxyRes, directRes, originFilePath, done) {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.statusCode).toEqual(directRes.statusCode);
// expect(proxyRes.headers.reqbody).toEqual(directRes.headers.reqbody);
// the body will be the file path
const directUploadedStream = fs.createReadStream(directRes.body);
const proxyUploadedStream = fs.createReadStream(proxyRes.body);
const localFileStream = fs.createReadStream(originFilePath);
streamEqual(directUploadedStream, localFileStream)
.then(isLocalEqual => {
expect(isLocalEqual).toBe(true);
streamEqual(directUploadedStream, proxyUploadedStream)
.then(isUploadedEqual => {
expect(isUploadedEqual).toBe(true);
done();
}, error => {
console.error('error in comparing directUpload with proxy:\n', error);
done.fail('error in comparing directUpload with proxy');
});
done();
}, error => {
console.error('error in comparing directUpload with local:\n', error);
done.fail('error in comparing directUpload with local');
});
}
});
});
}

134
test/spec_rule/no_rule_websocket_spec.js
View File

@@ -1,134 +0,0 @@
/*
* Test suites for WebSocket.
* ONLY TO ENSURE THE REQUEST WILL BE BYPASSED SUCCESSFULLY, WE HAVEN'T SUPPORTTED WEBSOCKET YET.
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { generateWsUrl, directWs, proxyWs } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog, isArrayEqual, isCommonReqEqual } = require('../util/CommonUtil.js');
testWebsocket('ws');
testWebsocket('wss');
testWebsocket('ws', true);
testWebsocket('wss', true);
function testWebsocket(protocol, masked = false) {
describe('Test WebSocket in protocol : ' + protocol, () => {
const url = generateWsUrl(protocol, '/test/socket');
let serverInstance;
let proxyServer;
// the message to
const testMessageArray = [
'Send the message with default option1',
'Send the message with default option2',
'Send the message with default option3',
'Send the message with default option4'
];
const websocketHeaders = {
referer: 'https://www.anyproxy.io/websocket/test',
origin: 'www.anyproxy.io'
}
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 200000;
printLog('Start server for no_rule_websocket_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.defaultProxyServer();
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Closed server for no_rule_websocket_spec');
});
it('Default websocket option', done => {
const directMessages = []; // set the flag for direct message, compare when both direct and proxy got message
const proxyMessages = [];
let directResHeaders;
let proxyResHeaders;
const ws = directWs(url, websocketHeaders);
const proxyWsRef = proxyWs(url, websocketHeaders);
ws.on('open', () => {
ws.send(testMessageArray[0], masked);
for (let i = 1; i < testMessageArray.length; i++) {
setTimeout(() => {
ws.send(testMessageArray[i], masked);
}, 1000);
}
});
proxyWsRef.on('open', () => {
try {
proxyWsRef.send(testMessageArray[0], masked);
for (let i = 1; i < testMessageArray.length; i++) {
setTimeout(() => {
proxyWsRef.send(testMessageArray[i], masked);
}, 1000);
}
} catch (e) {
console.error(e);
}
});
ws.on('upgrade', (res) => {
directResHeaders = res.headers;
compareMessageIfReady();
});
proxyWsRef.on('upgrade', (res) => {
proxyResHeaders = res.headers;
compareMessageIfReady();
});
ws.on('message', (data, flag) => {
const message = JSON.parse(data);
if (message.type === 'onMessage') {
directMessages.push(message.content);
compareMessageIfReady();
}
});
proxyWsRef.on('message', (data, flag) => {
const message = JSON.parse(data);
if (message.type === 'onMessage') {
proxyMessages.push(message.content);
compareMessageIfReady();
}
});
ws.on('error', error => {
console.error('error happened in direct websocket:', error);
done.fail('Error happened in direct websocket');
});
proxyWsRef.on('error', error => {
console.error('error happened in proxy websocket:', error);
done.fail('Error happened in proxy websocket');
});
function compareMessageIfReady() {
const targetLen = testMessageArray.length;
if (directMessages.length === targetLen
&& proxyMessages.length === targetLen
&& directResHeaders && proxyResHeaders
) {
expect(isArrayEqual(directMessages, testMessageArray)).toBe(true);
expect(isArrayEqual(directMessages, proxyMessages)).toBe(true);
expect(directResHeaders['x-anyproxy-websocket']).toBeUndefined();
expect(proxyResHeaders['x-anyproxy-websocket']).toBe('true');
expect(isCommonReqEqual(url, serverInstance)).toBe(true);
done();
}
}
});
});
}

22
test/spec_rule/rule/rule_replace_request_data.js
View File

@@ -1,22 +0,0 @@
/*
* add authToken parameter to the request data
*
*/
module.exports = {
*beforeSendRequest(requestDetail) {
if (requestDetail.url.indexOf('/getuser') >= 0) {
let requestStr = requestDetail.requestData.toString();
try {
requestStr = JSON.stringify(Object.assign(JSON.parse(requestStr), {
authToken: 'auth_token_inrule'
}))
} catch (e) {
requestStr += '&authToken=auth_token_inrule';
}
return {
requestOptions: requestDetail.requestOptions,
requestData: requestStr
};
}
}
};

13
test/spec_rule/rule/rule_replace_request_option.js
View File

@@ -1,13 +0,0 @@
//rule scheme :
module.exports = {
*beforeSendRequest(requestDetail) {
const newOption = requestDetail.requestOptions;
if (newOption.hostname === 'localhost' && newOption.path === '/test/should_replace_option') {
newOption.path = '/test/new_replace_option';
return {
requestOptions: newOption
}
}
}
};

15
test/spec_rule/rule/rule_replace_request_protocol.js
View File

@@ -1,15 +0,0 @@
//rule scheme :
module.exports = {
*summary() {
return 'The rule to replace request protocol';
},
*beforeSendRequest(requestDetail) {
const newConfig = {
protocol: 'http',
requestOptions: requestDetail.requestOptions
};
newConfig.requestOptions.port = 3000;
return newConfig;
}
};

17
test/spec_rule/rule/rule_replace_response_data.js
View File

@@ -1,17 +0,0 @@
//rule scheme : replace the reponse data
module.exports = {
*beforeSendResponse(requestDetail, responseDetail) {
if (requestDetail.url.indexOf('/test/normal_request1') > -1) {
const newResponse = responseDetail.response;
const newDataStr = newResponse.body.toString() + '_hello_world!';
newResponse.body = newDataStr;
return {
response: newResponse
};
}
}
};

30
test/spec_rule/rule/rule_replace_response_header.js
View File

@@ -1,30 +0,0 @@
//rule scheme : remove the cache headers in response headers
module.exports = {
*summary() {
return 'The rule to remove the cache headers in response';
},
*beforeSendResponse(requestDetail, responseDetail) {
if (requestDetail.url.indexOf('/test/normal_request1') >= 0) {
const newResponse = responseDetail.response;
newResponse.header.replacedheaderkey = 'replacedHeader_value_in_rule';
return {
response: newResponse
};
}
}
// replaceResponseHeader(req, res, header) {
// const d = Q.defer();
// header = Object.assign({}, header);
// if (req.url.indexOf('test/normal_request1') > -1) {
// header.replacedheaderkey = 'replacedHeader_value_in_rule';
// }
// d.resolve(header);
// return d.promise;
// }
};

20
test/spec_rule/rule/rule_replace_response_status_code.js
View File

@@ -1,20 +0,0 @@
//replace all the images with local one
module.exports = {
*summary() {
return 'replace the response status code.';
},
*beforeSendResponse(requestDetail, responseDetail) {
if (requestDetail.url.indexOf('/test/normal_request1') >= 0) {
const newResponse = responseDetail.response;
newResponse.statusCode = 302;
newResponse.header.location = 'www.taobao.com';
return {
response: newResponse
};
}
},
};

19
test/spec_rule/rule/rule_should_intercept_https_req.js
View File

@@ -1,19 +0,0 @@
//rule scheme :
module.exports = {
*summary() {
return 'Rule to intercept https request';
},
*beforeSendResponse(requestDetail, responseDetail) {
const newResponse = responseDetail.response;
newResponse.body = newResponse.body.toString() + '_hello_world';
return {
response: newResponse
};
},
*beforeDealHttpsRequest(requestDetail) {
return requestDetail.host.indexOf('localhost:3001') > -1;
}
};

21
test/spec_rule/rule/rule_should_use_local_response.js
View File

@@ -1,21 +0,0 @@
/*
* Rule defination for shouldUseLocalResponse
*
*/
const localData = 'handled_in_local_response';
module.exports = {
*beforeSendRequest(requestDetail) {
if (requestDetail.url.indexOf('uselocal') > -1) {
return {
response: {
statusCode: 200,
header: {
'Via-Proxy-Local': 'true'
},
body: localData
}
};
}
}
};

155
test/spec_rule/rule_deal_error_spec.js
View File

@@ -1,155 +0,0 @@
/*
* test for rule replaceResponseStatus rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet } = require('../util/HttpUtil.js');
const { printLog } = require('../util/CommonUtil.js');
const domain_not_exists = 'not_exist.not_exist_anyproxy_io_domain.com';
let errorInRule = null;
const ruleNotDealError = {
*onError(requestDetail, error) {
errorInRule = error;
}
};
let errorInConnect = null;
const ruleDealConnectError = {
*onConnectError(requestDetail, error) {
errorInConnect = error;
}
};
const ERROR_PAGE_IN_RULE = 'this is my error page';
const ruleReturnAnErrorPage = {
*onError(requestDetail, error) {
return {
response: {
statusCode: '200',
header: {},
body: ERROR_PAGE_IN_RULE,
}
};
}
};
testWrapper('http');
testWrapper('https');
testHttpsConnect();
function testWrapper(protocol) {
describe('Rule should get an error in :' + protocol, () => {
let proxyServer;
// let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_deal_error_spec');
errorInRule = null;
proxyServer = ProxyServerUtil.proxyServerWithRule(ruleNotDealError);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
// serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_deal_error_spec');
});
it('Should get a request error', done => {
const url = protocol + `://${domain_not_exists}`;
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(500);
expect(proxyRes.headers['proxy-error']).toEqual('true');
expect(errorInRule).not.toBe(null);
done();
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
describe('Rule should return a custom error page in :' + protocol, () => {
let proxyServer;
// let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_deal_error_custom_error_page');
proxyServer = ProxyServerUtil.proxyServerWithRule(ruleReturnAnErrorPage);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
// serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_deal_error_custom_error_page');
});
it('Should get a request error', done => {
const url = protocol + `://${domain_not_exists}`;
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.headers['proxy-error']).toBe(undefined);
expect(proxyRes.body).toEqual(ERROR_PAGE_IN_RULE);
done();
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
}
function testHttpsConnect() {
describe('Rule should get a connect error', () => {
let proxyServer;
// let serverInstance;
beforeAll((done) => {
errorInConnect = null;
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_deal_error_custom_error_page');
proxyServer = ProxyServerUtil.proxyServerWithRule(ruleDealConnectError, {
forceProxyHttps: false
});
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
proxyServer && proxyServer.close();
printLog('Close server for rule_deal_error_custom_error_page');
});
it('Should get a request error', done => {
const url = `https://${domain_not_exists}`;
proxyGet(url)
.then(proxyRes => {
done.fail('should throw an error when requesting');
})
.catch(error => {
expect(errorInConnect).not.toBe(null);
done();
});
});
});
}

120
test/spec_rule/rule_replace_request_data_spec.js
View File

@@ -1,120 +0,0 @@
/*
* test for rule replaceRequestData rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyPost, generateUrl, directPost, isViaProxy } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog, isObjectEqual } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_request_data.js');
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule replaceRequestData should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_request_data_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_request_data_spec');
});
it('Should replace the request data in proxy if the assertion is true', done => {
const url = generateUrl(protocol, '/test/getuser');
const userName = 'username_test';
const param = {
username: userName
};
proxyPost(url, param)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('body_post_getuser');
const proxyRequest = serverInstance.getProxyRequestRecord(url);
const proxyReqBodyObj = JSON.parse(proxyRequest.body.toString());
expect(isViaProxy(proxyRequest)).toBe(true);
expect(proxyReqBodyObj.username).toEqual(userName);
expect(proxyReqBodyObj.authToken).toEqual('auth_token_inrule');
directPost(url, param)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual(proxyRes.body);
const directRequest = serverInstance.getRequestRecord(url);
const directReqBodyObj = JSON.parse(directRequest.body.toString());
expect(isViaProxy(directRequest)).toBe(false);
expect(directReqBodyObj.username).toEqual(userName);
expect(directReqBodyObj.authToken).toBeUndefined();
done();
})
.catch(error => {
console.error('error happened in direct post: ', error);
done.fail('error happened in direct post');
});
})
.catch(error => {
console.error('error happened in proxy post: ', error);
console.error(error);
console.error(error.stack);
done.fail('error happened in proxy post');
});
});
it('Should not replace the request data in proxy if the assertion is false', done => {
const url = generateUrl(protocol, '/test/normal_post_request1');
const userName = 'normal_username_test';
const param = {
username: userName
};
proxyPost(url, param)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('body_normal_post_request1');
const proxyReqRecord = serverInstance.getProxyRequestRecord(url);
const proxyReqBody = JSON.parse(proxyReqRecord.body);
expect(isObjectEqual(proxyReqBody, param, url)).toBe(true);
directPost(url, param)
.then(directRes => {
expect(directRes.statusCode).toEqual(proxyRes.statusCode);
expect(directRes.body).toEqual(proxyRes.body);
const directReqRecord = serverInstance.getRequestRecord(url);
const directReqBody = JSON.parse(directReqRecord.body);
expect(isObjectEqual(directReqBody, proxyReqBody, url)).toBe(true);
done();
})
.catch(error => {
console.error('error happened in direct post:', error);
done.fail('error happened in direct post');
});
})
.catch(error => {
console.error('error happened in proxy post:', error);
done.fail('error happened in proxy post');
});
});
});
}

89
test/spec_rule/rule_replace_request_option_spec.js
View File

@@ -1,89 +0,0 @@
/*
* test for rule replaceOption rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_request_option.js');
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule replaceRequestOption should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll(done => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_request_option_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_request_option_spec');
});
it('Should replace request option if the assertion is true', done => {
const url = generateUrl(protocol, '/test/should_replace_option');
const replacedUrl = generateUrl(protocol, '/test/new_replace_option');
const token = 'replacedOption' + Date.now();
const directToken = 'notRepacedOption' + Date.now();
proxyGet(url, {}, { token })
.then(proxyRes => {
directGet(url, {}, { token: directToken })
.then(directRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('the_new_replaced_option_page_content');
const proxyRequestObj = serverInstance.getProxyRequestRecord(replacedUrl);
expect(proxyRequestObj.headers.token).toEqual(token);
expect(proxyRequestObj.headers['via-proxy']).toEqual('true');
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('the_request_that_has_not_be_replaced');
const directRequestObj = serverInstance.getRequestRecord(url);
expect(directRequestObj.headers.token).toEqual(directToken);
done();
}).catch(error => {
console.error('error happened in direct get for replaceOption rule: ', error);
done.fail('error happened when direct test replaceOption rule ');
});
}).catch(error => {
console.error('error happened in proxy get for replaceOption rule: ', error);
done.fail('error happened when proxy test replaceOption rule ');
});
});
it('Should not replace request option if the assertion is false', done => {
const url = generateUrl(protocol, '/test/should_not_replace_option');
proxyGet(url)
.then(proxyRes => {
done();
}, error => {
console.error('error happened in proxy get:', error);
done.fail('error happened in proxy get');
}).catch(error => {
console.error('error happend in syntax:', error);
done.fail('error happend in syntax');
});
});
});
}

112
test/spec_rule/rule_replace_request_protocol_spec.js
View File

@@ -1,112 +0,0 @@
/*
* test for rule replaceOption rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_request_protocol.js');
testWrapper();
function testWrapper() {
describe('Rule replaceRequestProtocol should be working', () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_request_protocol');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_request_protocol');
});
it('Should replace request protocol in PROXY https request', done => {
const url = generateUrl('https', '/test/normal_request1');
const httpUrl = url.replace('https', 'http');
const token = 'proxy_request1_token_' + Date.now();
proxyGet(url, {}, { token })
.then(proxyRes => {
expect(proxyRes.body).toEqual('body_normal_request1');
// there should be no https url be requested in proxy, it should be http request
expect(serverInstance.getProxyRequestRecord(url)).toBe(null);
const httpRecord = serverInstance.getProxyRequestRecord(httpUrl);
expect(httpRecord.headers.token).toEqual(token);
expect(httpRecord.headers['via-proxy']).toEqual('true');
done();
})
.catch(error => {
console.error('Error happened in proxy the https request: ', error);
done.fail('error happened in proxy the https request');
});
});
it('Should not replace protocol in PROXY http request', done => {
const url = generateUrl('http', '/test/normal_request2');
const token = 'proxy_request2_token_' + Date.now();
proxyGet(url, {}, { token })
.then(proxyRes => {
expect(proxyRes.body).toEqual('body_normal_request2');
const requestRecord = serverInstance.getProxyRequestRecord(url);
expect(requestRecord).not.toBe(null);
expect(requestRecord.headers.token).toEqual(token);
expect(requestRecord.headers['via-proxy']).toEqual('true');
done();
})
.catch(error => {
console.error('error happened in proxy the http request: ', error);
done.fail('error happend in proxy the http request');
});
});
it('Should the direct request still be working with https', done => {
const url = generateUrl('https', '/test/normal_request1');
const token = 'direct_request1_token_' + Date.now();
directGet(url, {}, { token })
.then(directRes => {
expect(directRes.body).toEqual('body_normal_request1');
const requestRecord = serverInstance.getRequestRecord(url);
expect(requestRecord.headers.token).toEqual(token);
expect(requestRecord.headers['via-proxy']).toBeUndefined();
done();
})
.catch(error => {
console.error('error happened in direct https get:', error);
done.fail('error happened in direct https get');
});
});
it('Should the direct request still be working with http', done => {
const url = generateUrl('http', '/test/normal_request2');
const token = 'direct_request1_token_' + Date.now();
directGet(url, {}, { token })
.then(directRes => {
expect(directRes.body).toEqual('body_normal_request2');
const requestRecord = serverInstance.getRequestRecord(url);
expect(requestRecord.headers.token).toEqual(token);
expect(requestRecord.headers['via-proxy']).toBeUndefined();
done();
})
.catch(error => {
console.error('error happened in direct http get:', error);
done.fail('error happened in direct http get');
});
});
});
}

87
test/spec_rule/rule_replace_response_data_spec.js
View File

@@ -1,87 +0,0 @@
/*
* test for rule replaceResponseData rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_response_data.js');
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule replaceResponseData should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_response_data');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_response_data');
});
it('Should replace the header in proxy if assertion is true', done => {
const url = generateUrl(protocol, '/test/normal_request1');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('body_normal_request1_hello_world!');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('body_normal_request1');
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
it('Should not replace the header in proxy if assertion is false', done => {
const url = generateUrl(protocol, '/test/normal_request2');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('body_normal_request2');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual(proxyRes.body);
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
}

91
test/spec_rule/rule_replace_response_header_spec.js
View File

@@ -1,91 +0,0 @@
/*
* test for rule replaceResponseHeader rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_response_header.js');
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule replaceResponseHeader should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_response_header_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_response_header_spec');
});
it('Should replace the header in proxy if assertion is true', done => {
const url = generateUrl(protocol, '/test/normal_request1');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.headers.replacedheaderkey).toEqual('replacedHeader_value_in_rule');
expect(proxyRes.body).toEqual('body_normal_request1');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.headers.replacedheaderkey).toBeUndefined();
expect(directRes.body).toEqual(proxyRes.body);
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
it('Should not replace the header in proxy if the assertion is false', done => {
const url = generateUrl(protocol, '/test/normal_request2');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.headers.replacedheaderkey).toBeUndefined();
expect(proxyRes.body).toEqual('body_normal_request2');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.headers.replacedheaderkey).toBeUndefined();
expect(directRes.body).toEqual(proxyRes.body);
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
}

87
test/spec_rule/rule_replace_response_status_code_spec.js
View File

@@ -1,87 +0,0 @@
/*
* test for rule replaceResponseStatus rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_replace_response_status_code.js');
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule replaceResponseStatus should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_replace_response_status_code');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_replace_response_status_code');
});
it('Should replace the status code in proxy if assertion is true', done => {
const url = generateUrl(protocol, '/test/normal_request1');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(302);
expect(proxyRes.headers.location).toEqual('www.taobao.com');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('body_normal_request1');
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
it('Should not replace the status code in proxy if assertion is false', done => {
const url = generateUrl(protocol, '/test/normal_request2');
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(proxyRes.body).toEqual('body_normal_request2');
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body).toEqual('body_normal_request2');
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
}

87
test/spec_rule/rule_should_intercept_https_req_spec.js
View File

@@ -1,87 +0,0 @@
/*
* test for rule shouldInterceptHttpsReq rule
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, directGet } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_should_intercept_https_req.js');
testWrapper();
function testWrapper() {
describe('Rule shouldInterceptHttpsReq should be working', () => {
let proxyServer;
let serverInstance;
beforeAll(done => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for test_rule_should_intercept_https_req_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule, {
forceProxyHttps: false
});
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for test_rule_should_intercept_https_req_spec');
});
it('Should replace the header in proxy if assertion is true', done => {
const url = 'https://localhost:3001/test';
proxyGet(url)
.then(proxyRes => {
directGet(url)
.then(directRes => {
expect(proxyRes.statusCode).toEqual(200);
expect(directRes.statusCode).toEqual(200);
expect(directRes.body + '_hello_world').toEqual(proxyRes.body);
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
it('Should not replace the header in proxy if assertion is false', done => {
const url = 'https://localhost:3002/test';
proxyGet(url)
.then(proxyRes => {
expect(proxyRes.statusCode).toEqual(200);
directGet(url)
.then(directRes => {
expect(directRes.statusCode).toEqual(200);
expect(directRes.body.replace(/\s/g, '')).toEqual(proxyRes.body.replace(/\s/g, ''));
done();
})
.catch(error => {
console.error('error happened in direct get: ', error);
done.fail('error happened in direct get');
});
})
.catch(error => {
console.error('error happened in proxy get: ', error);
done.fail('error happened in proxy get');
});
});
});
}

55
test/spec_rule/rule_should_use_local_response_spec.js
View File

@@ -1,55 +0,0 @@
/*
* test for rule shouldUseLocal
*
*/
const ProxyServerUtil = require('../util/ProxyServerUtil.js');
const { proxyGet, generateUrl } = require('../util/HttpUtil.js');
const Server = require('../server/server.js');
const { printLog } = require('../util/CommonUtil.js');
const rule = require('./rule/rule_should_use_local_response.js');
const expectedLocalBody = 'handled_in_local_response';
testWrapper('http');
testWrapper('https');
function testWrapper(protocol) {
describe('Rule shouldUseLocalResponse should be working in :' + protocol, () => {
let proxyServer;
let serverInstance;
beforeAll((done) => {
jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
printLog('Start server for rule_shouldUseLocalResponse_spec');
serverInstance = new Server();
proxyServer = ProxyServerUtil.proxyServerWithRule(rule);
setTimeout(() => {
done();
}, 2000);
});
afterAll(() => {
serverInstance && serverInstance.close();
proxyServer && proxyServer.close();
printLog('Close server for rule_shouldUseLocalResponse_spec');
});
it('Should use local response if the assertion is true', done => {
const url = generateUrl(protocol, '/test/uselocal');
proxyGet(url, {})
.then(res => {
expect(res.body).toEqual(expectedLocalBody);
expect(res.headers['via-proxy-local']).toEqual('true');
done();
}).catch((error) => {
console.log('error happened in proxy get for shouldUseLocal: ', error);
done.fail('error happened when test shouldUseLocal rule');
});
});
});
}