diff --git a/test/__snapshots__/basic.spec.js.snap b/test/__snapshots__/basic.spec.js.snap index c7dc7ef..3d3b398 100644 --- a/test/__snapshots__/basic.spec.js.snap +++ b/test/__snapshots__/basic.spec.js.snap @@ -22,11 +22,17 @@ exports[`http - HTTP verbs PATCH: data 1`] = `""`; exports[`http - HTTP verbs POST body and header: args 1`] = `Object {}`; -exports[`http - HTTP verbs POST body and header: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`http - HTTP verbs POST body and header: data 1`] = ` +"1 +" +`; exports[`http - HTTP verbs PUT: args 1`] = `Object {}`; -exports[`http - HTTP verbs PUT: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`http - HTTP verbs PUT: data 1`] = ` +"1 +" +`; exports[`https - HTTP verbs DELETE: args 1`] = ` Object { @@ -50,8 +56,14 @@ exports[`https - HTTP verbs PATCH: data 1`] = `""`; exports[`https - HTTP verbs POST body and header: args 1`] = `Object {}`; -exports[`https - HTTP verbs POST body and header: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`https - HTTP verbs POST body and header: data 1`] = ` +"1 +" +`; exports[`https - HTTP verbs PUT: args 1`] = `Object {}`; -exports[`https - HTTP verbs PUT: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`https - HTTP verbs PUT: data 1`] = ` +"1 +" +`; diff --git a/test/basic.spec.js b/test/basic.spec.js new file mode 100644 index 0000000..84206d2 --- /dev/null +++ b/test/basic.spec.js @@ -0,0 +1,247 @@ + +process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; +const path = require('path'); +const fs = require('fs'); +const urllib = require('urllib'); +const request = require('request'); +const { basicProxyRequest, proxyServerWithRule, } = require('./util.js'); +const http = require('http'); +const WebSocket = require('ws'); +const tunnel = require('tunnel'); + +let proxyServer; +let proxyPort; +let proxyHost; +let proxyWebInterfaceHost; +beforeAll(async () => { + jest.DEFAULT_TIMEOUT_INTERVAL = 20 * 1000; + proxyServer = await proxyServerWithRule({}, {}); + proxyPort = proxyServer.proxyPort; + proxyHost = `http://localhost:${proxyPort}`; + const proxyWebInterfacePort = proxyServer.webServerInstance.webPort; + proxyWebInterfaceHost = `http://localhost:${proxyWebInterfacePort}`; +}); + +afterAll(() => { + return proxyServer && proxyServer.close(); +}); + +function doProxyWebSocket(url, headers = {}) { + let agent = new tunnel.httpOverHttp({ + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + + if (url.indexOf('wss') === 0) { + agent = new tunnel.httpsOverHttp({ + rejectUnauthorized: false, + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + } + + const ws = new WebSocket(url, { + agent, + rejectUnauthorized: false, + headers + }); + + return ws; +} + +['http', 'https'].forEach(protocol => { + describe.only(`${protocol} - HTTP verbs`, () => { + const assertProxyRes = (result) => { + const proxyRes = result.response; + const body = JSON.parse(result.body); + expect(proxyRes.statusCode).toBe(200); + expect(body.args).toMatchSnapshot('args'); + expect(body.data).toMatchSnapshot('data'); + return body; + }; + + it('GET', async () => { + const url = `${protocol}://httpbin.org/get`; + const getParam = { + param: 'param_value' + }; + await basicProxyRequest(proxyHost, 'GET', url, {}, getParam).then(assertProxyRes); + }); + + it('POST body and header', async () => { + const url = `${protocol}://httpbin.org/post`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/image.png')); + + const postHeaders = { + anyproxy_header: 'header_value', + }; + + const body = await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then(assertProxyRes); + expect(body.headers['Anyproxy-Header']).toBe(postHeaders.anyproxy_header); + }); + + it('PUT', async () => { + const url = `${protocol}://httpbin.org/put`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/image.png')); + await basicProxyRequest(proxyHost, 'PUT', url, {}, undefined, payloadStream).then(assertProxyRes); + }); + + it('DELETE', async () => { + const url = `${protocol}://httpbin.org/delete`; + const param = { + foo: 'bar', + }; + await basicProxyRequest(proxyHost, 'DELETE', url, {}, param).then(assertProxyRes); + }); + + it('PATCH', async () => { + const url = `${protocol}://httpbin.org/patch`; + await basicProxyRequest(proxyHost, 'PATCH', url).then(assertProxyRes); + }); + + it.only('Websocket', async () => { + const expectEcho = (ws) => { + return new Promise((resolve, reject) => { + const wsMsg = Buffer.alloc(100 * 1024, 'a').toString(); // 100kb + + ws.on('open', () => { + ws.send(wsMsg); + }); + + ws.on('message', (msg) => { + expect(msg).toBe(wsMsg); + ws.close(); + resolve(); + }); + }); + }; + + const wsUrl = `${protocol === 'https' ? 'wss' : 'ws'}://echo.websocket.org`; + const ws = doProxyWebSocket(wsUrl, {}); + await expectEcho(ws); + }); + }); +}); + +describe('status code and headers', () => { + [302, 404, 500].forEach(statusCode => { + it(`GET ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'GET', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + + it(`PUT ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'PUT', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + }); +}); + +describe('response data formats', () => { + ['brotli', 'deflate', 'gzip'].forEach(encoding => { + it(`GET ${encoding}`, async () => { + const url = `http://httpbin.org/${encoding}`; + const result = await basicProxyRequest(proxyHost, 'GET', url); + const headers = result.response.headers; + const body = JSON.parse(result.body); + expect(headers['content-encoding']).toBeUndefined(); // should be removed by anyproxy + expect(body.brotli || body.deflated || body.gzipped).toBeTruthy(); + }); + }); +}); + +describe('big files', () => { + const BIG_FILE_SIZE = 100 * 1024 * 1024 - 1; // 100 mb + const BUFFER_FILL = 'a'; + + let server; + beforeAll(() => { + server = http.createServer({}, (req, res) => { + if (/download/.test(req.url)) { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + res.write(bufferContent); + res.end(); + } else if (/upload/.test(req.url)) { + let reqPayloadSize = 0; + req.on('data', (data) => { + const bufferLength = data.length; + reqPayloadSize += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + res.statusCode = 500; + res.write('content not match'); + } + }).on('end', () => { + if (res.statusCode === 500 || reqPayloadSize !== BIG_FILE_SIZE) { + res.statusCode = 500; + } else { + res.statusCode = 200; + } + res.end(); + }); + } + }); + + server.listen(3000); + }); + + afterAll((done) => { + server && server.close(done); + }); + + it('download big file', (done) => { + let responseSizeCount = 0; + request({ + url: 'http://127.0.0.1:3000/download', + proxy: proxyHost, + }).on('data', (data) => { + const bufferLength = data.length; + responseSizeCount += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + return done(new Error('download content not match')); + } + }).on('end', () => { + if (responseSizeCount !== BIG_FILE_SIZE) { + return done(new Error('file size not match')); + } + done(); + }); + }, 120 * 1000); + + it('upload big file', (done) => { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + const req = request({ + url: 'http://127.0.0.1:3000/upload', + method: 'POST', + proxy: proxyHost, + }, (err, response, body) => { + if (err) { + return done(err); + } else if (response.statusCode !== 200) { + return done(new Error('upload failed ' + body)); + } + done(); + }); + req.write(bufferContent); + req.end(); + }, 120 * 1000); +}); + +describe('web interface', () => { + it('should be available', async () => { + await urllib.request(proxyWebInterfaceHost).then((result) => { + expect(result.status).toBe(200); + }); + }); +}); diff --git a/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) b/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) new file mode 100644 index 0000000..47cb354 --- /dev/null +++ b/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) @@ -0,0 +1,247 @@ + +process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; +const path = require('path'); +const fs = require('fs'); +const urllib = require('urllib'); +const request = require('request'); +const { basicProxyRequest, proxyServerWithRule, } = require('./util.js'); +const http = require('http'); +const WebSocket = require('ws'); +const tunnel = require('tunnel'); + +let proxyServer; +let proxyPort; +let proxyHost; +let proxyWebInterfaceHost; +beforeAll(async () => { + jest.DEFAULT_TIMEOUT_INTERVAL = 20 * 1000; + proxyServer = await proxyServerWithRule({}, {}); + proxyPort = proxyServer.proxyPort; + proxyHost = `http://localhost:${proxyPort}`; + const proxyWebInterfacePort = proxyServer.webServerInstance.webPort; + proxyWebInterfaceHost = `http://localhost:${proxyWebInterfacePort}`; +}); + +afterAll(() => { + return proxyServer && proxyServer.close(); +}); + +function doProxyWebSocket(url, headers = {}) { + let agent = new tunnel.httpOverHttp({ + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + + if (url.indexOf('wss') === 0) { + agent = new tunnel.httpsOverHttp({ + rejectUnauthorized: false, + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + } + + const ws = new WebSocket(url, { + agent, + rejectUnauthorized: false, + headers + }); + + return ws; +} + +['http', 'https'].forEach(protocol => { + describe(`${protocol} - HTTP verbs`, () => { + const assertProxyRes = (result) => { + const proxyRes = result.response; + const body = JSON.parse(result.body); + expect(proxyRes.statusCode).toBe(200); + expect(body.args).toMatchSnapshot('args'); + expect(body.data).toMatchSnapshot('data'); + return body; + }; + + it('GET', async () => { + const url = `${protocol}://httpbin.org/get`; + const getParam = { + param: 'param_value' + }; + await basicProxyRequest(proxyHost, 'GET', url, {}, getParam).then(assertProxyRes); + }); + + it('POST body and header', async () => { + const url = `${protocol}://httpbin.org/post`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/upload.txt')); + + const postHeaders = { + anyproxy_header: 'header_value', + }; + + const body = await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then(assertProxyRes); + expect(body.headers['Anyproxy-Header']).toBe(postHeaders.anyproxy_header); + }); + + it('PUT', async () => { + const url = `${protocol}://httpbin.org/put`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/upload.txt')); + await basicProxyRequest(proxyHost, 'PUT', url, {}, undefined, payloadStream).then(assertProxyRes); + }); + + it('DELETE', async () => { + const url = `${protocol}://httpbin.org/delete`; + const param = { + foo: 'bar', + }; + await basicProxyRequest(proxyHost, 'DELETE', url, {}, param).then(assertProxyRes); + }); + + it('PATCH', async () => { + const url = `${protocol}://httpbin.org/patch`; + await basicProxyRequest(proxyHost, 'PATCH', url).then(assertProxyRes); + }); + + it('Websocket', async () => { + const expectEcho = (ws) => { + return new Promise((resolve, reject) => { + const wsMsg = Buffer.alloc(100 * 1024, 'a').toString(); // 100kb + + ws.on('open', () => { + ws.send(wsMsg); + }); + + ws.on('message', (msg) => { + expect(msg).toBe(wsMsg); + ws.close(); + resolve(); + }); + }); + }; + + const wsUrl = `${protocol === 'https' ? 'wss' : 'ws'}://echo.websocket.org`; + const ws = doProxyWebSocket(wsUrl, {}); + await expectEcho(ws); + }); + }); +}); + +describe('status code and headers', () => { + [302, 404, 500].forEach(statusCode => { + it(`GET ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'GET', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + + it(`PUT ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'PUT', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + }); +}); + +describe('response data formats', () => { + ['brotli', 'deflate', 'gzip'].forEach(encoding => { + it(`GET ${encoding}`, async () => { + const url = `http://httpbin.org/${encoding}`; + const result = await basicProxyRequest(proxyHost, 'GET', url); + const headers = result.response.headers; + const body = JSON.parse(result.body); + expect(headers['content-encoding']).toBeUndefined(); // should be removed by anyproxy + expect(body.brotli || body.deflated || body.gzipped).toBeTruthy(); + }); + }); +}); + +describe('big files', () => { + const BIG_FILE_SIZE = 100 * 1024 * 1024 - 1; // 100 mb + const BUFFER_FILL = 'a'; + + let server; + beforeAll(() => { + server = http.createServer({}, (req, res) => { + if (/download/.test(req.url)) { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + res.write(bufferContent); + res.end(); + } else if (/upload/.test(req.url)) { + let reqPayloadSize = 0; + req.on('data', (data) => { + const bufferLength = data.length; + reqPayloadSize += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + res.statusCode = 500; + res.write('content not match'); + } + }).on('end', () => { + if (res.statusCode === 500 || reqPayloadSize !== BIG_FILE_SIZE) { + res.statusCode = 500; + } else { + res.statusCode = 200; + } + res.end(); + }); + } + }); + + server.listen(3000); + }); + + afterAll((done) => { + server && server.close(done); + }); + + it('download big file', (done) => { + let responseSizeCount = 0; + request({ + url: 'http://127.0.0.1:3000/download', + proxy: proxyHost, + }).on('data', (data) => { + const bufferLength = data.length; + responseSizeCount += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + return done(new Error('download content not match')); + } + }).on('end', () => { + if (responseSizeCount !== BIG_FILE_SIZE) { + return done(new Error('file size not match')); + } + done(); + }); + }, 120 * 1000); + + it('upload big file', (done) => { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + const req = request({ + url: 'http://127.0.0.1:3000/upload', + method: 'POST', + proxy: proxyHost, + }, (err, response, body) => { + if (err) { + return done(err); + } else if (response.statusCode !== 200) { + return done(new Error('upload failed ' + body)); + } + done(); + }); + req.write(bufferContent); + req.end(); + }, 120 * 1000); +}); + +describe('web interface', () => { + it('should be available', async () => { + await urllib.request(proxyWebInterfaceHost).then((result) => { + expect(result.status).toBe(200); + }); + }); +}); diff --git a/test/fixtures/image.png b/test/fixtures/image.png deleted file mode 100644 index f5416aa..0000000 Binary files a/test/fixtures/image.png and /dev/null differ diff --git a/test/fixtures/upload.txt b/test/fixtures/upload.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/test/fixtures/upload.txt @@ -0,0 +1 @@ +1 diff --git a/test/rule/beforeDealHttpsRequest.spec.js b/test/rule/beforeDealHttpsRequest.spec.js index d8d04e4..0bcbfed 100644 --- a/test/rule/beforeDealHttpsRequest.spec.js +++ b/test/rule/beforeDealHttpsRequest.spec.js @@ -34,11 +34,11 @@ describe('Rule beforeDealHttpsRequest', () => { }); it('Should replace the https request body', async () => { const url = 'https://httpbin.org/put'; - const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/image.png')); + const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/upload.txt')); const postHeaders = { anyproxy_header: 'header_value', }; - + await basicProxyRequest(proxyHost, 'PUT', url, postHeaders, {}, payloadStream).then((result) => { const proxyRes = result.response; const body = JSON.parse(result.body); diff --git a/test/rule/beforeSendRequest.spec.js b/test/rule/beforeSendRequest.spec.js index 965808a..52c3131 100644 --- a/test/rule/beforeSendRequest.spec.js +++ b/test/rule/beforeSendRequest.spec.js @@ -58,11 +58,11 @@ describe('Rule replaceRequestData', () => { it('should replace the request data in proxy if the assertion is true', async () => { const url = 'http://httpbin.org/post'; - const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/image.png')); + const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/upload.txt')); const postHeaders = { anyproxy_header: 'header_value', }; - + await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then((result) => { const proxyRes = result.response; const body = JSON.parse(result.body); @@ -73,7 +73,7 @@ describe('Rule replaceRequestData', () => { }); it('should respond content specified in rule', async () => { - const url = 'http://httpbin.org/status/302'; + const url = 'http://httpbin.org/status/302'; await basicProxyRequest(proxyHost, 'GET', url).then((result) => { const proxyRes = result.response; const body = result.body; @@ -84,7 +84,7 @@ describe('Rule replaceRequestData', () => { }); it('should replace protocol and url', async () => { - const url = 'http://domain_not_exists.anyproxy.io/should_be_replaced'; + const url = 'http://domain_not_exists.anyproxy.io/should_be_replaced'; await basicProxyRequest(proxyHost, 'GET', url).then((result) => { const proxyRes = result.response; expect(proxyRes.statusCode).toBe(302);