Merge pull request #22 from truework/beta

feat: new build pipeline, tests, npm audit

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no-install prettier-standard --format --staged && npm run test

.husky/prepare-commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+exec < /dev/tty && node_modules/.bin/cz --hook || true

package.json

@@ -3,24 +3,20 @@
   "version": "1.2.0",
   "description": "Making fetch happen in Typescript.",
   "source": "index.ts",
-  "main": "dist/gretchen.js",
-  "module": "dist/gretchen.es.js",
-  "unpkg": "dist/gretchen.umd.js",
+  "main": "dist/gretchen.cjs.js",
+  "modern": "dist/gretchen.esm.js",
+  "module": "dist/gretchen.esm.js",
+  "unpkg": "dist/gretchen.iife.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "microbundle build",
+    "build": "microbundle",
     "watch": "microbundle watch",
-    "test": "ava tests/**.test.ts --verbose",
-    "format": "prettier-standard --format"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "prettier-standard --format --staged",
-      "prepare-commit-msg": "exec < /dev/tty && git cz --hook || true"
-    }
+    "test": "node test",
+    "format": "prettier-standard --format",
+    "prepare": "npx husky install && npx commitizen init cz-conventional-changelog --save-dev --save-exact"
   },
   "keywords": [
     "fetch",
@@ -53,24 +49,21 @@
   },
   "homepage": "https://github.com/truework/gretchen#readme",
   "devDependencies": {
-    "ava": "^2.4.0",
-    "commitizen": "^4.2.2",
+    "baretest": "^2.0.0",
+    "commitizen": "^4.2.4",
     "core-js": "^3.7.0",
     "cross-fetch": "^3.0.4",
     "cz-conventional-changelog": "^3.3.0",
-    "husky": "^4.2.3",
-    "microbundle": "^0.11.0",
+    "esbuild-register": "^2.6.0",
+    "husky": "^6.0.0",
+    "microbundle": "^0.13.3",
     "prettier-standard": "^16.4.1",
     "semantic-release": "^17.2.2",
-    "ts-node": "^8.4.1"
+    "typescript": "^4.3.3"
   },
-  "ava": {
-    "compileEnhancements": false,
-    "extensions": [
-      "ts"
-    ],
-    "require": [
-      "ts-node/register"
-    ]
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
   }
 }

test/handleRetry.test.ts

@@ -0,0 +1,236 @@
+import 'cross-fetch/polyfill'
+import { createServer } from 'http'
+
+import { handleRetry } from '../lib/handleRetry'
+import { handleTimeout } from '../lib/handleTimeout'
+
+export default (test, assert) => {
+  test('works', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(500)
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'GET',
+          {}
+        )
+        const res = await raw.text()
+
+        assert.equal(res, 'ha')
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('retries fail', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(500)
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'GET',
+          { attempts: 1 }
+        )
+        assert.equal(raw.status, 500)
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('respect 0 retries config', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(500)
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'GET',
+          { attempts: 0 }
+        )
+        assert.equal(raw.status, 500)
+        assert.equal(i, 1)
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('retries for specified status codes', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(400)
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'GET',
+          { codes: [400] }
+        )
+        const res = await raw.text()
+
+        assert.equal(res, 'ha')
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('retries for specified methods', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(500)
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'POST',
+          { methods: ['POST'] }
+        )
+        const res = await raw.text()
+
+        assert.equal(res, 'ha')
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('works with timeout', async () => {
+    const server = createServer((req, res) => {
+      setTimeout(() => {
+        res.end('ha')
+      }, 1000)
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const request = () =>
+          handleTimeout(fetch(`http://127.0.0.1:${port}`), 500)
+
+        try {
+          await handleRetry(request, 'GET', {})
+        } catch (e) {
+          assert.equal(e.name, 'HTTPTimeout')
+        }
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test('respects Retry-After header', async () => {
+    let i = 0
+    const server = createServer((req, res) => {
+      if (i++ < 2) {
+        res.writeHead(500, {
+          'Retry-After': 1
+        })
+        res.end()
+      } else {
+        res.end('ha')
+      }
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const then = Date.now()
+
+        const raw = await handleRetry(
+          () => fetch(`http://127.0.0.1:${port}`),
+          'GET',
+          {}
+        )
+
+        const now = Date.now()
+
+        // retried too fast
+        if (now - then < 1000) {
+          throw Error('fail')
+        }
+
+        const res = await raw.text()
+
+        assert.equal(res, 'ha')
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+}

test/handleTimeout.test.ts

@@ -0,0 +1,55 @@
+import 'cross-fetch/polyfill'
+import { createServer } from 'http'
+
+import { handleTimeout } from '../lib/handleTimeout'
+
+export default (test, assert) => {
+  test('will timeout', async () => {
+    const server = createServer((req, res) => {
+      setTimeout(() => {
+        res.end('ha')
+      }, 1000)
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        try {
+          await handleTimeout(fetch(`http://127.0.0.1:${port}`), 500)
+        } catch (e) {
+          assert.equal(e.name, 'HTTPTimeout')
+        }
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+
+  test("won't timeout", async () => {
+    const server = createServer((req, res) => {
+      setTimeout(() => {
+        res.end('ha')
+      }, 1000)
+    })
+
+    await new Promise(r => {
+      server.listen(async () => {
+        // @ts-ignore
+        const { port } = server.address()
+
+        const raw = await handleTimeout(fetch(`http://127.0.0.1:${port}`))
+        const res = await raw.text()
+
+        assert.equal(res, 'ha')
+
+        server.close()
+
+        r(0)
+      })
+    })
+  })
+}

test/index.js

@@ -0,0 +1,26 @@
+console.time('test')
+
+require('esbuild-register/dist/node').register()
+
+const test = require('baretest')('gretchen')
+const assert = require('assert')
+
+require('./utils.test').default(test, assert)
+require('./handleRetry.test').default(test, assert)
+require('./handleTimeout.test').default(test, assert)
+require('./index.test').default(test, assert)
+
+process.on('unhandledRejection', e => {
+  console.error(e)
+  process.exit(1)
+})
+
+!(async function () {
+  test.before(() => {})
+
+  test.after(() => {})
+
+  await test.run()
+
+  console.timeEnd('test')
+})()