update to 4.0

test/spec_rule/no_rule_big_response_spec.js

@@ -0,0 +1,42 @@
+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();
+      });
+    }
+  });
+});

test/spec_rule/no_rule_spec.js

@@ -0,0 +1,400 @@
+
+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');
+
+// Test suites for http and https request
+function testRequest(protocol = 'http') {
+  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();
+      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');
+        });
+    });
+
+    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');
+          });
+      }
+    });
+  });
+}

test/spec_rule/no_rule_websocket_spec.js

@@ -0,0 +1,140 @@
+/*
+* 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 } = require('../util/CommonUtil.js');
+
+testWebsocket('ws');
+testWebsocket('wss');
+
+function testWebsocket(protocol) {
+  describe('Test WebSocket in protocol : ' + protocol, () => {
+    const url = generateWsUrl(protocol, '/test/socket');
+    let serverInstance;
+    let proxyServer;
+
+    beforeAll((done) => {
+      jasmine.DEFAULT_TIMEOUT_INTERVAL = 200000;
+      printLog('Start server for no_rule_websocket_spec');
+      serverInstance = new Server();
+
+      proxyServer = ProxyServerUtil.proxyServerWithoutHttpsIntercept();
+
+      setTimeout(() => {
+        done();
+      }, 2000);
+    });
+
+    afterAll(() => {
+      serverInstance && serverInstance.close();
+      proxyServer && proxyServer.close();
+      printLog('Closed server for no_rule_websocket_spec');
+    });
+
+    it('Default websocket option', done => {
+      const sendMessage = 'Send the message with default option';
+      let directMessage; // set the flag for direct message, compare when both direct and proxy got message
+      let proxyMessage;
+
+      const ws = directWs(url);
+      const porxyWsRef = proxyWs(url);
+      ws.on('open', () => {
+        ws.send(sendMessage);
+      });
+
+      porxyWsRef.on('open', () => {
+        porxyWsRef.send(sendMessage);
+      });
+
+      ws.on('message', (data, flag) => {
+        const message = JSON.parse(data);
+        if (message.type === 'onMessage') {
+          directMessage = message.content;
+          compareMessageIfReady();
+        }
+      });
+
+      porxyWsRef.on('message', (data, flag) => {
+        const message = JSON.parse(data);
+        if (message.type === 'onMessage') {
+          proxyMessage = message.content;
+          compareMessageIfReady();
+        }
+      });
+
+      ws.on('error', error => {
+        console.error('error happened in direct websocket:', error);
+        done.fail('Error happened in direct websocket');
+      });
+
+      porxyWsRef.on('error', error => {
+        console.error('error happened in proxy websocket:', error);
+        done.fail('Error happened in proxy websocket');
+      });
+
+      function compareMessageIfReady() {
+        if (directMessage && proxyMessage) {
+          expect(directMessage).toEqual(proxyMessage);
+          expect(directMessage).toEqual(sendMessage);
+          done();
+        }
+      }
+    });
+
+    it('masked:true', done => {
+      const sendMessage = 'Send the message with option masked:true';
+      let directMessage; // set the flag for direct message, compare when both direct and proxy got message
+      let proxyMessage;
+
+      const ws = directWs(url);
+      const porxyWsRef = proxyWs(url);
+      ws.on('open', () => {
+        ws.send(sendMessage, { masked: true });
+      });
+
+      porxyWsRef.on('open', () => {
+        porxyWsRef.send(sendMessage, { masked: true });
+      });
+
+      ws.on('message', (data, flag) => {
+        const message = JSON.parse(data);
+        if (message.type === 'onMessage') {
+          directMessage = message.content;
+          compareMessageIfReady();
+        }
+      });
+
+      porxyWsRef.on('message', (data, flag) => {
+        const message = JSON.parse(data);
+        if (message.type === 'onMessage') {
+          proxyMessage = message.content;
+          compareMessageIfReady();
+        }
+      });
+
+      ws.on('error', error => {
+        console.error('error happened in direct websocket:', error);
+        done.fail('Error happened in direct websocket');
+      });
+
+      porxyWsRef.on('error', error => {
+        console.error('error happened in proxy websocket:', error);
+
+        done.fail('Error happened in proxy websocket');
+      });
+
+      function compareMessageIfReady() {
+        if (directMessage && proxyMessage) {
+          expect(directMessage).toEqual(proxyMessage);
+          expect(directMessage).toEqual(sendMessage);
+          done();
+        }
+      }
+    });
+  });
+}
+

test/spec_rule/rule/rule_replace_request_data.js

@@ -0,0 +1,22 @@
+/*
+* 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
+      };
+    }
+  }
+};

test/spec_rule/rule/rule_replace_request_option.js

@@ -0,0 +1,13 @@
+//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
+      }
+    }
+  }
+};

test/spec_rule/rule/rule_replace_request_protocol.js

@@ -0,0 +1,15 @@
+//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;
+  }
+};

test/spec_rule/rule/rule_replace_response_data.js

@@ -0,0 +1,17 @@
+//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
+      };
+    }
+  }
+};

test/spec_rule/rule/rule_replace_response_header.js

@@ -0,0 +1,30 @@
+//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;
+  // }
+};

test/spec_rule/rule/rule_replace_response_status_code.js

@@ -0,0 +1,20 @@
+//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
+      };
+    }
+  },
+};
+

test/spec_rule/rule/rule_should_intercept_https_req.js

@@ -0,0 +1,19 @@
+//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;
+  }
+};

test/spec_rule/rule/rule_should_use_local_response.js

@@ -0,0 +1,21 @@
+/*
+* 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
+        }
+      };
+    }
+  }
+};

test/spec_rule/rule_deal_error_spec.js

@@ -0,0 +1,154 @@
+/*
+* test for rule replaceResponseStatus rule
+*
+*/
+const ProxyServerUtil = require('../util/ProxyServerUtil.js');
+const { proxyGet } = require('../util/HttpUtil.js');
+
+const { printLog } = require('../util/CommonUtil.js');
+
+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 + '://not_exist_url.anyproxy.io';
+      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 + '://not_exist_url.anyproxy.io';
+      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://not_exist_url.anyproxy.io';
+      proxyGet(url)
+        .then(proxyRes => {
+          done.fail('should throw an error when requesting');
+        })
+        .catch(error => {
+          expect(errorInConnect).not.toBe(null);
+          done();
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_request_data_spec.js

@@ -0,0 +1,120 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_request_option_spec.js

@@ -0,0 +1,89 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_request_protocol_spec.js

@@ -0,0 +1,112 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_response_data_spec.js

@@ -0,0 +1,87 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_response_header_spec.js

@@ -0,0 +1,91 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_replace_response_status_code_spec.js

@@ -0,0 +1,87 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_should_intercept_https_req_spec.js

@@ -0,0 +1,87 @@
+/*
+* 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');
+        });
+    });
+  });
+}

test/spec_rule/rule_should_use_local_response_spec.js

@@ -0,0 +1,55 @@
+/*
+* 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');
+        });
+    });
+  });
+}