Update Mockttp for a massive key generation perf boost

Author: pimterry

package-lock.json

@@ -37,7 +37,7 @@
     "graphql": "^14.0.2",
     "graphql-yoga": "^1.16.7",
     "lodash": "^4.17.11",
-    "mockttp": "^0.13.0",
+    "mockttp": "^0.14.0",
     "node-gsettings-wrapper": "^0.5.0",
     "osx-find-executable": "^1.0.0",
     "rimraf": "^2.6.2",

package.json

@@ -26,8 +26,8 @@ async function generateHTTPSConfig(configPath: string) {
     await Promise.all([
         canAccess(keyPath, fs.constants.R_OK),
         canAccess(certPath, fs.constants.R_OK)
-    ]).catch(() => {
-        const newCertPair = generateCACertificate({
+    ]).catch(async () => {
+        const newCertPair = await generateCACertificate({
             commonName: 'HTTP Toolkit CA'
         });
 

src/index.ts

@@ -1,26 +1,31 @@
 import * as _ from 'lodash';
 import { CompletedRequest } from 'mockttp';
-import { getInterceptorAndServer, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
+import { setupInterceptor, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
 
-const { server, interceptor: chromeInterceptor } = getInterceptorAndServer('fresh-chrome');
+const interceptorSetup = setupInterceptor('fresh-chrome');
 
 describe('Chrome interceptor', function () {
     this.timeout(5000);
 
     beforeEach(async () => {
+        const { server } = await interceptorSetup;
         await server.start();
         await server.anyRequest().thenPassThrough();
     });
 
     afterEach(async () => {
+        const { server, interceptor: chromeInterceptor } = await interceptorSetup;
+
         await chromeInterceptor.deactivate(server.port);
         await server.stop();
     });
 
-    itIsAvailable(chromeInterceptor);
-    itCanBeActivated(chromeInterceptor, server);
+    itIsAvailable(interceptorSetup);
+    itCanBeActivated(interceptorSetup);
 
     it('successfully makes requests', async function () {
+        const { server, interceptor: chromeInterceptor } = await interceptorSetup;
+
         const exampleRequestReceived = new Promise<CompletedRequest>((resolve) =>
             server.on('request', (req) => {
                 if (req.url.startsWith('https://amiusing.httptoolkit.tech')) {

test/interceptors/fresh-chrome.spec.ts

@@ -1,28 +1,32 @@
 import * as _ from 'lodash';
 import { CompletedRequest } from 'mockttp';
-import { getInterceptorAndServer, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
+import { setupInterceptor, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
 
-const { server, interceptor: firefoxInterceptor } = getInterceptorAndServer('fresh-firefox');
+const interceptorSetup = setupInterceptor('fresh-firefox');
 
 describe('Firefox interceptor', function () {
     this.timeout(5000);
 
     beforeEach(async () => {
+        const { server } = await interceptorSetup;
         await server.start();
         await server.anyRequest().thenPassThrough();
     });
 
     afterEach(async () => {
+        const { server, interceptor: firefoxInterceptor } = await interceptorSetup;
         await firefoxInterceptor.deactivate(server.port);
         await server.stop();
     });
 
-    itIsAvailable(firefoxInterceptor);
-    itCanBeActivated(firefoxInterceptor, server);
+    itIsAvailable(interceptorSetup);
+    itCanBeActivated(interceptorSetup);
 
     // TODO: This doesn't work, as we need to manually accept the cert before
     // Firefox makes its HTTPS request to amiusing
     it.skip('successfully makes requests', async function () {
+        const { server, interceptor: firefoxInterceptor } = await interceptorSetup;
+
         const exampleRequestReceived = new Promise<CompletedRequest>((resolve) =>
             server.on('request', (req) => {
                 if (req.url.startsWith('https://amiusing.httptoolkit.tech')) {

test/interceptors/fresh-firefox.spec.ts

@@ -1,23 +1,24 @@
 import * as _ from 'lodash';
-import { CompletedRequest } from 'mockttp';
-import { getInterceptorAndServer, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
+import { setupInterceptor, itIsAvailable, itCanBeActivated } from './interceptor-test-utils';
 
-const { server, interceptor: terminalInterceptor } = getInterceptorAndServer('fresh-terminal');
+const interceptorSetup = setupInterceptor('fresh-terminal');
 
 describe('Terminal interceptor', function () {
     this.timeout(5000);
 
     beforeEach(async () => {
+        const { server } = await interceptorSetup;
         await server.start();
         await server.anyRequest().thenPassThrough();
     });
 
     afterEach(async () => {
+        const { server, interceptor: terminalInterceptor } = await interceptorSetup;
         await terminalInterceptor.deactivate(server.port);
         await server.stop();
     });
 
-    itIsAvailable(terminalInterceptor);
-    itCanBeActivated(terminalInterceptor, server);
+    itIsAvailable(interceptorSetup);
+    itCanBeActivated(interceptorSetup);
 
 });

test/interceptors/fresh-terminal.spec.ts

@@ -9,22 +9,27 @@ import { getLocal, generateCACertificate, Mockttp } from 'mockttp';
 
 import { buildInterceptors, Interceptor } from '../../src/interceptors';
 
-const getCertificateDetails = _.memoize((configPath: string) => {
+const getCertificateDetails = _.memoize(async (configPath: string) => {
     const keyPath = path.join(configPath, 'ca.key');
     const certPath = path.join(configPath, 'ca.pem');
 
-    const newCertPair = generateCACertificate({ commonName: 'HTTP Toolkit CA - DO NOT TRUST' });
+    const newCertPair = await generateCACertificate({ commonName: 'HTTP Toolkit CA - DO NOT TRUST' });
 
     fs.writeFileSync(keyPath, newCertPair.key);
     fs.writeFileSync(certPath, newCertPair.cert);
 
     return { certPath, keyPath };
 });
 
-export function getInterceptorAndServer(interceptor: string): { server: Mockttp, interceptor: Interceptor } {
+type InterceptorSetup = Promise<{
+    server: Mockttp,
+    interceptor: Interceptor
+}>
+
+export async function setupInterceptor(interceptor: string): InterceptorSetup {
     const configPath = tmp.dirSync({ unsafeCleanup: true }).name;
 
-    const { certPath, keyPath } = getCertificateDetails(configPath);
+    const { certPath, keyPath } = await getCertificateDetails(configPath);
 
     const server = getLocal({ https: { certPath, keyPath } });
     const interceptors = buildInterceptors({ configPath, https: { certPath, keyPath } });
@@ -34,14 +39,17 @@ export function getInterceptorAndServer(interceptor: string): { server: Mockttp,
 
 // Various tests that we'll want to reuse across interceptors:
 
-export function itIsAvailable(interceptor: Interceptor) {
+export function itIsAvailable(interceptorSetup: InterceptorSetup) {
     it('is available', async () => {
+        const { interceptor } = await interceptorSetup;
         expect(await interceptor.isActivable()).to.equal(true);
     });
 }
 
-export function itCanBeActivated(interceptor: Interceptor, server: Mockttp) {
+export function itCanBeActivated(interceptorSetup: InterceptorSetup) {
     it('can be activated', async () => {
+        const { interceptor, server } = await interceptorSetup;
+
         expect(interceptor.isActive(server.port)).to.equal(false);
 
         await interceptor.activate(server.port);