fix(proxy): if the proxy is http, edit the request url (#366)

- clean up - move int and proxy test to async / await.

closes #359

Author: cnishina

lib/provider/chromedriver.spec-proxy.ts

@@ -49,7 +49,6 @@ describe('chromedriver', () => {
           done();
         }
         const chromeDriver = new ChromeDriver({
-          ignoreSSL: true,
           osType: 'Darwin',
           osArch: 'x64',
           outDir: tmpDir,

lib/provider/utils/http_utils.spec-int.ts

@@ -19,10 +19,11 @@ const fooArrayUrl = httpBaseUrl + '/spec/support/files/foo_array.json';
 const fooXmlUrl = httpBaseUrl + '/spec/support/files/foo.xml';
 const barZipSize = 171;
 
-describe('http_utils', () => {
-  const origTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
-  let proc: childProcess.ChildProcess;
+const origTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+let proc: childProcess.ChildProcess;
 
+describe('http_utils', () => {
+  
   beforeAll(() => {
     jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
   });
@@ -41,9 +42,6 @@ describe('http_utils', () => {
 
       try {
         fs.mkdirSync(tmpDir);
-      } catch (err) {
-      }
-      try {
         fs.unlinkSync(fileName);
       } catch (err) {
       }
@@ -63,30 +61,27 @@ describe('http_utils', () => {
     });
 
     describe('requestBinary', () => {
-      it('should download the file if no file exists or ' +
-             'the content lenght is different',
-         (done) => {
-           requestBinary(binaryUrl, {fileName, fileSize: 0})
-               .then((result) => {
-                 expect(result).toBeTruthy();
-                 expect(fs.statSync(fileName).size).toBe(barZipSize);
-                 done();
-               })
-               .catch(err => {
-                 done.fail(err);
-               });
-         });
+      it('should download the file if no file exists or the content lenght ' +
+         'is different', async () => {
+        try {
+          const result = await requestBinary(
+            binaryUrl, {fileName, fileSize: 0});
+          expect(result).toBeTruthy();
+          expect(fs.statSync(fileName).size).toBe(barZipSize);
+        } catch (err) {
+          fail(err);
+        }
+      });
 
-      it('should not download the file if the file exists', (done) => {
-        requestBinary(binaryUrl, {fileName, fileSize: barZipSize})
-            .then((result) => {
-              expect(result).toBeFalsy();
-              expect(fs.statSync(fileName).size).toBe(barZipSize);
-              done();
-            })
-            .catch(err => {
-              done.fail(err);
-            });
+      it('should not download the file if the file exists', async () => {
+        try {
+          const result = await requestBinary(
+            binaryUrl, {fileName, fileSize: barZipSize});
+          expect(result).toBeFalsy();
+          expect(fs.statSync(fileName).size).toBe(barZipSize);
+        } catch (err) {
+          fail(err);
+        }
       });
     });
 

lib/provider/utils/http_utils.spec-proxy.ts

@@ -14,6 +14,7 @@ log.setLevel('debug');
 
 const tmpDir = path.resolve(os.tmpdir(), 'test');
 const fileName = path.resolve(tmpDir, 'bar.zip');
+const ignoreSSL = true;
 const binaryUrl = proxyBaseUrl + '/spec/support/files/bar.zip';
 const fooJsonUrl = proxyBaseUrl + '/spec/support/files/foo_json.json';
 const fooArrayUrl = proxyBaseUrl + '/spec/support/files/foo_array.json';
@@ -22,31 +23,29 @@ const barZipSize = 171;
 const headers = {
   'host': httpBaseUrl
 };
+const origTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+let httpProc: childProcess.ChildProcess;
+let proxyProc: childProcess.ChildProcess;
 
-describe('binary_utils', () => {
-  const origTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
-  let httpProc: childProcess.ChildProcess;
-  let proxyProc: childProcess.ChildProcess;
-
-  beforeAll((done) => {
+describe('binary_utils', () => {  
+  beforeAll(async () => {
     jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
     httpProc = spawnProcess('node', ['dist/spec/server/http_server.js']);
     log.debug('http-server: ' + httpProc.pid);
     proxyProc = spawnProcess('node', ['dist/spec/server/proxy_server.js']);
     log.debug('proxy-server: ' + proxyProc.pid);
-    setTimeout(done, 3000);
+    await new Promise(resolve => {
+      setTimeout(resolve, 3000);
+    });
 
     try {
       fs.mkdirSync(tmpDir);
-    } catch (err) {
-    }
-    try {
       fs.unlinkSync(fileName);
     } catch (err) {
     }
   });
 
-  afterAll((done) => {
+  afterAll(async () => {
     try {
       fs.unlinkSync(fileName);
       fs.rmdirSync(tmpDir);
@@ -55,48 +54,48 @@ describe('binary_utils', () => {
 
     process.kill(httpProc.pid);
     process.kill(proxyProc.pid);
-    setTimeout(done, 5000);
+    await new Promise(resolve => {
+      setTimeout(resolve, 5000);
+    });
     jasmine.DEFAULT_TIMEOUT_INTERVAL = origTimeout;
   });
 
   describe('requestBinary', () => {
-    it('should download the file if no file exists or ' +
-           'the content lenght is different',
-       (done) => {
-         requestBinary(binaryUrl, {fileName, fileSize: 0, headers})
-             .then((result) => {
-               expect(result).toBeTruthy();
-               expect(fs.statSync(fileName).size).toBe(barZipSize);
-               done();
-             })
-             .catch(err => {
-               done.fail(err);
-             });
-       });
+    it('should download the file if no file exists or the content lenght ' + 
+       'is different', async () => {
+      try {
+        const result = await requestBinary(
+          binaryUrl, {fileName, fileSize: 0, headers, ignoreSSL});
+        expect(result).toBeTruthy();
+        expect(fs.statSync(fileName).size).toBe(barZipSize);
+      } catch (err) {
+        fail(err);
+      }
+    });
 
-    it('should not download the file if the file exists', (done) => {
-      requestBinary(binaryUrl, {fileName, fileSize: barZipSize, headers})
-          .then((result) => {
-            expect(result).toBeFalsy();
-            expect(fs.statSync(fileName).size).toBe(barZipSize);
-            done();
-          })
-          .catch(err => {
-            done.fail(err);
-          });
+    it('should not download the file if the file exists', async () => {
+      try {
+        const result = await requestBinary(
+          binaryUrl, {fileName, fileSize: barZipSize, headers,
+          ignoreSSL});
+        expect(result).toBeFalsy();
+        expect(fs.statSync(fileName).size).toBe(barZipSize);
+      } catch (err) {
+        fail(err);
+      }
     });
   });
 
   describe('requestBody', () => {
     it('should download a json object file', async () => {
-      const foo = await requestBody(fooJsonUrl, {headers});
+      const foo = await requestBody(fooJsonUrl, {headers, ignoreSSL});
       const fooJson = JSON.parse(foo);
       expect(fooJson['foo']).toBe('abc');
       expect(fooJson['bar']).toBe(123);
     });
 
     it('should download a json array file', async () => {
-      const foo = await requestBody(fooArrayUrl, {headers});
+      const foo = await requestBody(fooArrayUrl, {headers, ignoreSSL});
       const fooJson = JSON.parse(foo);
       expect(fooJson.length).toBe(3);
       expect(fooJson[0]['foo']).toBe('abc');
@@ -105,7 +104,7 @@ describe('binary_utils', () => {
     });
 
     it('should get the xml file', async () => {
-      const text = await requestBody(fooXmlUrl, {headers});
+      const text = await requestBody(fooXmlUrl, {headers, ignoreSSL});
       expect(text.length).toBeGreaterThan(0);
     });
   });

lib/provider/utils/http_utils.ts

@@ -82,7 +82,7 @@ export function optionsProxy(
     optProxy: string): RequestOptionsValue {
   if (optProxy) {
     options.proxy = resolveProxy(requestUrl, optProxy);
-    if (url.parse(requestUrl).protocol === 'https:') {
+    if (url.parse(options.proxy).protocol === 'http:') {
       options.url = requestUrl.replace('https:', 'http:');
     }
   }